mm: Page fault accounting cleanups
Subsystems (41)
Peter Xu
reviewercover mm: Page fault accounting cleanups
(Forgot to cc mm list on v1; adding in)
This is v2 of the pf accounting cleanup series. It originates from Gerald Schaefer's report on an issue a week ago regarding to incorrect page fault accountings for retried page fault after commit 4064b9827063 ("mm: allow VM_FAULT_RETRY for multiple times"):
https://lore.kernel.org/lkml/20200610174811.44b94525@thinkpad/
This version used a better approach suggested by Linus so that we do accounting directly in handle_mm_fault(). Moreover, we'll cover some special accounting too like gup or IOMMU fault requests on process page tables. The outcome of this series is to keep all the pf accountings in handle_mm_fault() (besides PERF_COUNT_SW_PAGE_FAULTS, which is still done in per-arch #pf handlers).
Since v2 changed quite a lot from v1, changelog is omitted, and I also didn't have a chance to pick up any r-b in previous version. I really appreciate anyone who has looked at v1. V1 for reference:
https://lore.kernel.org/lkml/[email protected]/
What this series did:
- Correct page fault accounting: we do accounting for a page fault (no matter whether it's from #PF handling, or gup, or anything else) only with the one that completed the fault. For example, page fault retries should not be counted in page fault counters. Same to the perf events.
- Unify definition of PERF_COUNT_SW_PAGE_FAULTS: currently this perf event is used in an adhoc way across different archs.
Case (1): for many archs it's done at the entry of a page fault handler, so that it will also cover e.g. errornous faults.
Case (2): for some other archs, it is only accounted when the page fault is resolved successfully.
Case (3): there're still quite some archs that have not enabled this perf event.
Since this series will touch merely all the archs, we unify this perf event to always follow case (1), which is the one that makes most sense. And since we moved the accounting into handle_mm_fault, the other two MAJ/MIN perf events are well taken care of naturally.
- Unify definition of "major faults": the definition of "major fault" is slightly changed when used in accounting (not VM_FAULT_MAJOR). More information in patch 1.
- Always account the page fault onto the one that triggered the page fault. This does not matter much for #PF handlings, but mostly for gup. More information on this in patch 25.
Patchset layout:
Patch 1: Introduced the accounting in handle_mm_fault(), not enabled. Patch 2-24: Enable the new accounting for arch #PF handlers one by one. Patch 25: Enable the new accounting for the rest outliers (gup, iommu, etc.) Patch 26: Cleanup GUP task_struct pointer since it's not needed any more
For each of the patch that fixes a specific arch, I'm CCing the maintainers and the arch list if there is. Besides, I only lightly tested this series on x86.
Please have a look, thanks.
Peter Xu (26):
mm: Do page fault accounting in handle_mm_fault mm/alpha: Use general page fault accounting mm/arc: Use general page fault accounting mm/arm: Use general page fault accounting mm/arm64: Use general page fault accounting mm/csky: Use general page fault accounting mm/hexagon: Use general page fault accounting mm/ia64: Use general page fault accounting mm/m68k: Use general page fault accounting mm/microblaze: Use general page fault accounting mm/mips: Use general page fault accounting mm/nds32: Use general page fault accounting mm/nios2: Use general page fault accounting mm/openrisc: Use general page fault accounting mm/parisc: Use general page fault accounting mm/powerpc: Use general page fault accounting mm/riscv: Use general page fault accounting mm/s390: Use general page fault accounting mm/sh: Use general page fault accounting mm/sparc32: Use general page fault accounting mm/sparc64: Use general page fault accounting mm/unicore32: Use general page fault accounting mm/x86: Use general page fault accounting mm/xtensa: Use general page fault accounting
mm: Clean up the last pieces of page fault accountings mm/gup: Remove task_struct pointer for all gup code
arch/alpha/mm/fault.c | 8 +- arch/arc/kernel/process.c | 2 +- arch/arc/mm/fault.c | 18 +--- arch/arm/mm/fault.c | 25 ++--- arch/arm64/mm/fault.c | 29 ++---- arch/csky/mm/fault.c | 13 +-- arch/hexagon/mm/vm_fault.c | 9 +- arch/ia64/mm/fault.c | 9 +- arch/m68k/mm/fault.c | 14 +-- arch/microblaze/mm/fault.c | 9 +- arch/mips/mm/fault.c | 14 +-- arch/nds32/mm/fault.c | 19 +--- arch/nios2/mm/fault.c | 14 +-- arch/openrisc/mm/fault.c | 9 +- arch/parisc/mm/fault.c | 8 +- arch/powerpc/mm/copro_fault.c | 7 +- arch/powerpc/mm/fault.c | 11 +- arch/riscv/mm/fault.c | 16 +-- arch/s390/kvm/interrupt.c | 2 +- arch/s390/kvm/kvm-s390.c | 2 +- arch/s390/kvm/priv.c | 8 +- arch/s390/mm/fault.c | 16 +-- arch/s390/mm/gmap.c | 4 +- arch/sh/mm/fault.c | 11 +- arch/sparc/mm/fault_32.c | 13 +-- arch/sparc/mm/fault_64.c | 11 +- arch/um/kernel/trap.c | 6 +- arch/unicore32/mm/fault.c | 14 +-- arch/x86/mm/fault.c | 17 +--- arch/xtensa/mm/fault.c | 15 +-- drivers/gpu/drm/i915/gem/i915_gem_userptr.c | 2 +- drivers/infiniband/core/umem_odp.c | 2 +- drivers/iommu/amd_iommu_v2.c | 2 +- drivers/iommu/intel-svm.c | 2 +- drivers/vfio/vfio_iommu_type1.c | 2 +- fs/exec.c | 2 +- include/linux/mm.h | 16 +-- kernel/events/uprobes.c | 6 +- kernel/futex.c | 2 +- mm/gup.c | 107 +++++++------------- mm/hmm.c | 3 +- mm/ksm.c | 3 +- mm/memory.c | 72 ++++++++++++- mm/process_vm_access.c | 2 +- security/tomoyo/domain.c | 2 +- virt/kvm/async_pf.c | 2 +- virt/kvm/kvm_main.c | 2 +- 47 files changed, 222 insertions(+), 360 deletions(-)
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 1/26 mm: Do page fault accounting in handle_mm_fault
This is a preparation patch to move page fault accountings into the general code in handle_mm_fault(). This includes both the per task flt_maj/flt_min counters, and the major/minor page fault perf events. To do this, the pt_regs pointer is passed into handle_mm_fault().
PERF_COUNT_SW_PAGE_FAULTS should still be kept in per-arch page fault handlers.
So far, all the pt_regs pointer that passed into handle_mm_fault() is NULL, which means this patch should have no intented functional change.
--- arch/alpha/mm/fault.c | 2 +- arch/arc/mm/fault.c | 2 +- arch/arm/mm/fault.c | 2 +- arch/arm64/mm/fault.c | 2 +- arch/csky/mm/fault.c | 3 +- arch/hexagon/mm/vm_fault.c | 2 +- arch/ia64/mm/fault.c | 2 +- arch/m68k/mm/fault.c | 2 +- arch/microblaze/mm/fault.c | 2 +- arch/mips/mm/fault.c | 2 +- arch/nds32/mm/fault.c | 2 +- arch/nios2/mm/fault.c | 2 +- arch/openrisc/mm/fault.c | 2 +- arch/parisc/mm/fault.c | 2 +- arch/powerpc/mm/copro_fault.c | 2 +- arch/powerpc/mm/fault.c | 2 +- arch/riscv/mm/fault.c | 2 +- arch/s390/mm/fault.c | 2 +- arch/sh/mm/fault.c | 2 +- arch/sparc/mm/fault_32.c | 4 +-- arch/sparc/mm/fault_64.c | 2 +- arch/um/kernel/trap.c | 2 +- arch/unicore32/mm/fault.c | 2 +- arch/x86/mm/fault.c | 2 +- arch/xtensa/mm/fault.c | 2 +- drivers/iommu/amd_iommu_v2.c | 2 +- drivers/iommu/intel-svm.c | 2 +- include/linux/mm.h | 7 ++-- mm/gup.c | 4 +-- mm/hmm.c | 3 +- mm/ksm.c | 3 +- mm/memory.c | 66 ++++++++++++++++++++++++++++++++++- 32 files changed, 105 insertions(+), 35 deletions(-)
arch/alpha/mm/fault.c +1 -1
@@ -148,7 +148,7 @@ do_page_fault(unsigned long address, unsigned long mmcsr,/* If for any reason at all we couldn't handle the fault, make sure we exit gracefully rather than endlessly redo the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/arc/mm/fault.c +1 -1
@@ -131,7 +131,7 @@ void do_page_fault(unsigned long address, struct pt_regs *regs) goto bad_area; } - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );/* Quick path to respond to signals */ if (fault_signal_pending (fault, regs)) {
arch/arm/mm/fault.c +1 -1
@@ -223,7 +223,7 @@ __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr, goto out; } -return handle_mm_fault (vma, addr &PAGE_MASK , flags); +return handle_mm_fault (vma, addr &PAGE_MASK , flags,NULL ); check_stack:/* Don't allow expansion below FIRST_USER_ADDRESS */
arch/arm64/mm/fault.c +1 -1
@@ -422,7 +422,7 @@ static vm_fault_t __do_page_fault(struct mm_struct *mm, unsigned long addr,*/ if (!(vma->vm_flags & vm_flags))return VM_FAULT_BADACCESS ; -return handle_mm_fault (vma, addr &PAGE_MASK , mm_flags); +return handle_mm_fault (vma, addr &PAGE_MASK , mm_flags,NULL ); }static bool is_el0_instruction_abort (unsigned int esr)
arch/csky/mm/fault.c +2 -1
@@ -150,7 +150,8 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, write ?FAULT_FLAG_WRITE :0 ); + fault =handle_mm_fault (vma, address, write ?FAULT_FLAG_WRITE :0 , +NULL );if (unlikely (fault &VM_FAULT_ERROR )) {if (fault &VM_FAULT_OOM ) goto out_of_memory;
arch/hexagon/mm/vm_fault.c +1 -1
@@ -89,7 +89,7 @@ void do_page_fault(unsigned long address, long cause, struct pt_regs *regs)break ; } - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/ia64/mm/fault.c +1 -1
@@ -139,7 +139,7 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re* sure we exit gracefully rather than endlessly redo the * fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/m68k/mm/fault.c +1 -1
@@ -135,7 +135,7 @@ int do_page_fault(struct pt_regs *regs, unsigned long address,* the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );pr_debug ("handle_mm_fault returns %x\n" , fault);if (fault_signal_pending (fault, regs))
arch/microblaze/mm/fault.c +1 -1
@@ -215,7 +215,7 @@ void do_page_fault(struct pt_regs *regs, unsigned long address,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/mips/mm/fault.c +1 -1
@@ -152,7 +152,7 @@ static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/nds32/mm/fault.c +1 -1
@@ -207,7 +207,7 @@ void do_page_fault(unsigned long entry, unsigned long addr,* the fault. */ - fault =handle_mm_fault (vma, addr, flags); + fault =handle_mm_fault (vma, addr, flags,NULL );/* * If we need to retry but a fatal signal is pending, handle the
arch/nios2/mm/fault.c +1 -1
@@ -131,7 +131,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long cause,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/openrisc/mm/fault.c +1 -1
@@ -159,7 +159,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long address,* the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/parisc/mm/fault.c +1 -1
@@ -302,7 +302,7 @@ void do_page_fault(struct pt_regs *regs, unsigned long code,* fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
arch/powerpc/mm/copro_fault.c +1 -1
@@ -64,7 +64,7 @@ int copro_handle_mm_fault(struct mm_struct *mm, unsigned long ea, } ret =0 ; - *flt =handle_mm_fault (vma, ea, is_write ?FAULT_FLAG_WRITE :0 ); + *flt =handle_mm_fault (vma, ea, is_write ?FAULT_FLAG_WRITE :0 ,NULL );if (unlikely (*flt &VM_FAULT_ERROR )) {if (*flt &VM_FAULT_OOM ) { ret = -ENOMEM ;
arch/powerpc/mm/fault.c +1 -1
@@ -563,7 +563,7 @@ static int __do_page_fault(struct pt_regs *regs, unsigned long address,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );#ifdef CONFIG_PPC_MEM_KEYS /*
arch/riscv/mm/fault.c +1 -1
@@ -110,7 +110,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, addr, flags); + fault =handle_mm_fault (vma, addr, flags,NULL );/* * If we need to retry but a fatal signal is pending, handle the
arch/s390/mm/fault.c +1 -1
@@ -479,7 +479,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs)) { fault =VM_FAULT_SIGNAL ;if (flags &FAULT_FLAG_RETRY_NOWAIT )
arch/sh/mm/fault.c +1 -1
@@ -464,7 +464,7 @@ asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (unlikely (fault & (VM_FAULT_RETRY |VM_FAULT_ERROR )))if (mm_fault_error (regs, error_code, address, fault))
arch/sparc/mm/fault_32.c +2 -2
@@ -235,7 +235,7 @@ asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
@@ -411,7 +411,7 @@ static void force_user_fault(unsigned long address, int write)if (!(vma->vm_flags & (VM_READ |VM_EXEC ))) goto bad_area; } -switch (handle_mm_fault (vma, address, flags)) { +switch (handle_mm_fault (vma, address, flags,NULL )) {case VM_FAULT_SIGBUS :case VM_FAULT_OOM : goto do_sigbus;
arch/sparc/mm/fault_64.c +1 -1
@@ -423,7 +423,7 @@ asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs) goto bad_area; } - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs)) goto exit_exception;
arch/um/kernel/trap.c +1 -1
@@ -75,7 +75,7 @@ int handle_page_fault(unsigned long address, unsigned long ip, do { vm_fault_t fault; - fault = handle_mm_fault(vma, address, flags); + fault = handle_mm_fault(vma, address, flags, NULL); if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current)) goto out_nosemaphore;
arch/unicore32/mm/fault.c +1 -1
@@ -186,7 +186,7 @@ static vm_fault_t __do_pf(struct mm_struct *mm, unsigned long addr,* If for any reason at all we couldn't handle the fault, make * sure we exit gracefully rather than endlessly redo the fault. */ - fault =handle_mm_fault (vma, addr &PAGE_MASK , flags); + fault =handle_mm_fault (vma, addr &PAGE_MASK , flags,NULL );return fault; check_stack:
arch/x86/mm/fault.c +1 -1
@@ -1461,7 +1461,7 @@ void do_user_addr_fault(struct pt_regs *regs,* userland). The return to userland is identified whenever * FAULT_FLAG_USER|FAULT_FLAG_KILLABLE are both set in flags. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL ); major |= fault &VM_FAULT_MAJOR ;/* Quick path to respond to signals */
arch/xtensa/mm/fault.c +1 -1
@@ -108,7 +108,7 @@ void do_page_fault(struct pt_regs *regs)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags); + fault =handle_mm_fault (vma, address, flags,NULL );if (fault_signal_pending (fault, regs))return ;
drivers/iommu/amd_iommu_v2.c +1 -1
@@ -497,7 +497,7 @@ static void do_fault(struct work_struct *work)if (access_error (vma, fault)) goto out; - ret =handle_mm_fault (vma, address, flags); + ret =handle_mm_fault (vma, address, flags,NULL ); out:up_read (&mm->mmap_sem);
drivers/iommu/intel-svm.c +1 -1
@@ -629,7 +629,7 @@ static irqreturn_t prq_event_thread(int irq, void *d) goto invalid; ret =handle_mm_fault (vma, address, - req->wr_req ?FAULT_FLAG_WRITE :0 ); + req->wr_req ?FAULT_FLAG_WRITE :0 ,NULL );if (ret &VM_FAULT_ERROR ) goto invalid;
include/linux/mm.h +5 -2
@@ -36,6 +36,7 @@ struct file_ra_state;struct user_struct ;struct writeback_control ;struct bdi_writeback ; +struct pt_regs ;void init_mm_internals (void );
@@ -1652,7 +1653,8 @@ int invalidate_inode_page(struct page *page);#ifdef CONFIG_MMU extern vm_fault_t handle_mm_fault (struct vm_area_struct *vma, -unsigned long address,unsigned int flags); +unsigned long address,unsigned int flags, +struct pt_regs *regs);extern int fixup_user_fault (struct task_struct *tsk,struct mm_struct *mm,unsigned long address,unsigned int fault_flags,bool *unlocked);
@@ -1662,7 +1664,8 @@ void unmap_mapping_range(struct address_space *mapping, loff_t const holebegin, loff_t const holelen, int even_cows);#else static inline vm_fault_t handle_mm_fault (struct vm_area_struct *vma, -unsigned long address,unsigned int flags) +unsigned long address,unsigned int flags, +struct pt_regs *regs) {/* should never happen if there's no MMU */ BUG ();
mm/gup.c +2 -2
@@ -876,7 +876,7 @@ static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma, fault_flags |=FAULT_FLAG_TRIED ; } - ret =handle_mm_fault (vma, address, fault_flags); + ret =handle_mm_fault (vma, address, fault_flags,NULL );if (ret &VM_FAULT_ERROR ) {int err =vm_fault_to_errno (ret, *flags);
@@ -1222,7 +1222,7 @@ int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm, fatal_signal_pending(current))return -EINTR ; - ret =handle_mm_fault (vma, address, fault_flags); + ret =handle_mm_fault (vma, address, fault_flags,NULL ); major |= ret &VM_FAULT_MAJOR ;if (ret &VM_FAULT_ERROR ) {int err =vm_fault_to_errno (ret,0 );
mm/hmm.c +2 -1
@@ -90,7 +90,8 @@ static int hmm_vma_fault(unsigned long addr, unsigned long end, }for (; addr < end; addr +=PAGE_SIZE ) -if (handle_mm_fault (vma, addr, fault_flags) &VM_FAULT_ERROR ) +if (handle_mm_fault (vma, addr, fault_flags,NULL ) & +VM_FAULT_ERROR )return -EFAULT ;return -EBUSY ; }
mm/ksm.c +2 -1
@@ -480,7 +480,8 @@ static int break_ksm(struct vm_area_struct *vma, unsigned long addr)break ;if (PageKsm (page)) ret =handle_mm_fault (vma, addr, -FAULT_FLAG_WRITE |FAULT_FLAG_REMOTE ); +FAULT_FLAG_WRITE |FAULT_FLAG_REMOTE , +NULL );else ret =VM_FAULT_WRITE ;put_page (page);
mm/memory.c +65 -1
90 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH 01/26] mm: Do page fault accounting in handle_mm_fault
On Fri, 19 Jun 2020 12:05:13 -0400
Peter Xu <[email protected]> wrote:
[...]
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4429
Quoted 6 lines
mm/memory.c +2
-0@@ -4393,6 +4425,38 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,mem_cgroup_oom_synchronize (false); } +if (ret &VM_FAULT_RETRY ) +return ret;
I'm wondering if this also needs a check and exit for VM_FAULT_ERROR. In arch code (s390 and all others I briefly checked), the accounting was skipped for VM_FAULT_ERROR case.
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4438
Quoted 9 lines
mm/memory.c +9
-0+ +/* +* Do accounting in the common code, to avoid unnecessary +* architecture differences or duplicated code. +* +* We arbitrarily make the rules be: +* +* - faults that never even got here (because the address +* wasn't valid). That includes arch_vma_access_permitted()
Missing "do not count" at the end of the first sentence?
Quoted 4 lines
mm/memory.c +4
-0+* failing above. +* +* So this is expressly not a "this many hardware page +* faults" counter. Use the hw profiling for that.
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4452
Quoted 10 lines
mm/memory.c +10
-0+* +* - incomplete faults (ie RETRY) do not count (see above). +* They will only count once completed. +* +* - the fault counts as a "major" fault when the final +* successful fault is VM_FAULT_MAJOR, or if it was a +* retry (which implies that we couldn't handle it +* immediately previously). +* +* - if the fault is done for GUP, regs wil be NULL and
wil -> will
Regards,
Gerald
Peter Xu
reviewerRe: [PATCH 01/26] mm: Do page fault accounting in handle_mm_fault
Quoted 9 lines · Gerald Schaefer
On Fri, 19 Jun 2020 12:05:13 -0400
Peter Xu <[email protected]> wrote:[...]
Quoted 4 lines
mm/memory.c +0
-0@@ -4393,6 +4425,38 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,mem_cgroup_oom_synchronize (false); }
Quoted 6 lines
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4429
Quoted 2 lines
mm/memory.c +2
-0+if (ret &VM_FAULT_RETRY ) +return ret;I'm wondering if this also needs a check and exit for
VM_FAULT_ERROR. In arch code (s390 and all others I briefly checked), the accounting was skipped forVM_FAULT_ERRORcase.
Yes. I didn't explicitly add the check because I thought it's still OK to count the error cases, especially after we've discussed about PERF_COUNT_SW_PAGE_FAULTS in v1. So far, the major reason (iiuc) to have PERF_COUNT_SW_PAGE_FAULTS still in per-arch handlers is to also cover these corner cases like VM_FAULT_ERROR. So to me it makes sense too to also count them in here. But I agree it changes the old counting on most archs.
Again, I don't have strong opinion either on this, just like the same to PERF_COUNT_SW_PAGE_FAULTS... But if no one disagree, I will change this to:
if (ret & (VM_FAULT_RETRY | VM_FAULT_ERROR))
return ret;
So we try our best to follow the past.
Btw, note that there will still be some even more special corner cases. E.g., for ARM64 it's also not accounted for some ARM64 specific fault errors (VM_FAULT_BADMAP, VM_FAULT_BADACCESS). So even if we don't count VM_FAULT_ERROR, we might still count these for ARM64. We can try to redefine VM_FAULT_ERROR in ARM64 to cover all the arch-specific errors, however that seems an overkill to me sololy for fault accountings, so hopefully I can ignore that difference.
Quoted 13 lines
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4438
Quoted 10 lines
mm/memory.c +9
-0+ +/* +* Do accounting in the common code, to avoid unnecessary +* architecture differences or duplicated code. +* +* We arbitrarily make the rules be: +* +* - faults that never even got here (because the address +* wasn't valid). That includes arch_vma_access_permitted() Missing "do not count" at the end of the first sentence?
Quoted 16 lines
Quoted 4 lines
mm/memory.c +4
-0+* failing above. +* +* So this is expressly not a "this many hardware page +* faults" counter. Use the hw profiling for that. mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4452
Quoted 10 lines
mm/memory.c +10
-0+* +* - incomplete faults (ie RETRY) do not count (see above). +* They will only count once completed. +* +* - the fault counts as a "major" fault when the final +* successful fault is VM_FAULT_MAJOR, or if it was a +* retry (which implies that we couldn't handle it +* immediately previously). +* +* - if the fault is done for GUP, regs wil be NULL and wil -> will
Will fix both places. Thanks,
Signature · 1 line
Peter Xu
Re: [PATCH 01/26] mm: Do page fault accounting in handle_mm_fault
Quoted 17 lines · On Wed, 24 Jun 2020 16:34:12 -0400 Peter Xu <[email protected]> wrote:
Quoted 9 lines · Gerald Schaefer
On Fri, 19 Jun 2020 12:05:13 -0400
Peter Xu <[email protected]> wrote:[...]
Quoted 4 lines
mm/memory.c +0
-0@@ -4393,6 +4425,38 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,mem_cgroup_oom_synchronize (false); }Quoted 6 lines
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4429
Quoted 2 lines
mm/memory.c +2
-0+if (ret &VM_FAULT_RETRY ) +return ret;I'm wondering if this also needs a check and exit for
VM_FAULT_ERROR. In arch code (s390 and all others I briefly checked), the accounting was skipped forVM_FAULT_ERRORcase.
Quoted 6 lines
Yes. I didn't explicitly add the check because I thought it's still OK to count the error cases, especially after we've discussed about
PERF_COUNT_SW_PAGE_FAULTSin v1. So far, the major reason (iiuc) to havePERF_COUNT_SW_PAGE_FAULTSstill in per-arch handlers is to also cover these corner cases likeVM_FAULT_ERROR. So to me it makes sense too to also count them in here. But I agree it changes the old counting on most archs.
Having PERF_COUNT_SW_PAGE_FAULTS count everything including VM_FAULT_ERROR is OK. Just major/minor accounting should be only about successes, IIRC from v1 discussion.
The "new rules" also say
+ * - faults that never even got here (because the address
+ * wasn't valid). That includes arch_vma_access_permitted()
+ * failing above.
VM_FAULT_ERROR, and also the arch-specific VM_FAULT_BADxxx, qualify as "address wasn't valid" I think, so they should not be counted as major/minor.
IIRC from v1, and we want to only count success as major/minor, maybe the rule could also be made more clear about that, e.g. like
+ * - unsuccessful faults (because the address wasn't valid)
+ * do not count. That includes arch_vma_access_permitted()
+ * failing above.
Quoted 8 lines
Again, I don't have strong opinion either on this, just like the same to
PERF_COUNT_SW_PAGE_FAULTS... But if no one disagree, I will change this to:if (ret & (
VM_FAULT_RETRY|VM_FAULT_ERROR))return ret;So we try our best to follow the past.
Sounds good to me, and VM_FAULT_BADxxx should never show up here.
Quoted 8 lines
Btw, note that there will still be some even more special corner cases. E.g., for ARM64 it's also not accounted for some ARM64 specific fault errors (
VM_FAULT_BADMAP,VM_FAULT_BADACCESS). So even if we don't countVM_FAULT_ERROR, we might still count these for ARM64. We can try to redefineVM_FAULT_ERRORin ARM64 to cover all the arch-specific errors, however that seems an overkill to me sololy for fault accountings, so hopefully I can ignore that difference.
Hmm, arm64 already does not count the VM_FAULT_BADxxx, but also does not call handle_mm_fault() for those, so no change with this patch. arm (and also unicore32) do count those, but also not call handle_mm_fault(), so there would be the change that they lose accounting, IIUC.
I agree that this probably can be ignored. The code in arm64 also looks more recent, so it's probably just a left-over in arm/unicore32 code.
Regards,
Gerald
Peter Xu
reviewerRe: [PATCH 01/26] mm: Do page fault accounting in handle_mm_fault
Quoted 44 lines · Gerald Schaefer
Quoted 17 lines · On Wed, 24 Jun 2020 16:34:12 -0400 Peter Xu <[email protected]> wrote:
Quoted 9 lines · Gerald Schaefer
On Fri, 19 Jun 2020 12:05:13 -0400
Peter Xu <[email protected]> wrote:[...]
Quoted 4 lines
mm/memory.c +0
-0@@ -4393,6 +4425,38 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,mem_cgroup_oom_synchronize (false); }Quoted 6 lines
mm/memory.c vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, · line 4429
Quoted 2 lines
mm/memory.c +2
-0+if (ret &VM_FAULT_RETRY ) +return ret;I'm wondering if this also needs a check and exit for
VM_FAULT_ERROR. In arch code (s390 and all others I briefly checked), the accounting was skipped forVM_FAULT_ERRORcase.Quoted 6 lines
Yes. I didn't explicitly add the check because I thought it's still OK to count the error cases, especially after we've discussed about
PERF_COUNT_SW_PAGE_FAULTSin v1. So far, the major reason (iiuc) to havePERF_COUNT_SW_PAGE_FAULTSstill in per-arch handlers is to also cover these corner cases likeVM_FAULT_ERROR. So to me it makes sense too to also count them in here. But I agree it changes the old counting on most archs.Having
PERF_COUNT_SW_PAGE_FAULTScount everything includingVM_FAULT_ERRORis OK. Just major/minor accounting should be only about successes, IIRC from v1 discussion.The "new rules" also say
mm/memory.c +3
-0+* - faults that never even got here (because the address +* wasn't valid). That includes arch_vma_access_permitted() +* failing above.
VM_FAULT_ERROR, and also the arch-specificVM_FAULT_BADxxx, qualify as "address wasn't valid" I think, so they should not be counted as major/minor.IIRC from v1, and we want to only count success as major/minor, maybe the rule could also be made more clear about that, e.g. like
Review
Quoted 3 lines
(quoted diff) +3
-0+ * - unsuccessful faults (because the address wasn't valid) + * do not count. That includes arch_vma_access_permitted() + * failing above.
Sure.
Quoted 21 lines
Quoted 9 lines
Again, I don't have strong opinion either on this, just like the same to
PERF_COUNT_SW_PAGE_FAULTS... But if no one disagree, I will change this to:if (ret & (
VM_FAULT_RETRY|VM_FAULT_ERROR))return ret;So we try our best to follow the past.
Sounds good to me, and
VM_FAULT_BADxxxshould never show up here.Quoted 8 lines
Btw, note that there will still be some even more special corner cases. E.g., for ARM64 it's also not accounted for some ARM64 specific fault errors (
VM_FAULT_BADMAP,VM_FAULT_BADACCESS). So even if we don't countVM_FAULT_ERROR, we might still count these for ARM64. We can try to redefineVM_FAULT_ERRORin ARM64 to cover all the arch-specific errors, however that seems an overkill to me sololy for fault accountings, so hopefully I can ignore that difference.
Quoted 4 lines
Hmm, arm64 already does not count the
VM_FAULT_BADxxx, but also does not callhandle_mm_fault()for those, so no change with this patch. arm (and also unicore32) do count those, but also not callhandle_mm_fault(), so there would be the change that they lose accounting, IIUC.
Oh you are right... I just noticed that VM_FAULT_BADMAP and VM_FAULT_BADACCESS can never returned in handle_mm_fault() itself.
Quoted 3 lines
I agree that this probably can be ignored. The code in arm64 also looks more recent, so it's probably just a left-over in arm/unicore32 code.
Anyway, glad to know that we've reached consensus so that we can accept these differences.
Since this patch seems to be the only one that needs a new post so far, I'll repost this patch only by replying to itself with v2.1. Hopefully that can avoid some unecessary mail bombs.
Thanks for the very detailed review!
Signature · 1 line
Peter Xu
Peter Xu
reviewerRe: [PATCH 01/26] mm: Do page fault accounting in handle_mm_fault
Quoted 3 lines · Peter Xu
Since this patch seems to be the only one that needs a new post so far, I'll repost this patch only by replying to itself with v2.1. Hopefully that can avoid some unecessary mail bombs.
Unluckily patch 25 will need a trivial touch-up on the comment... I'll just resend the whole series for simplicity. Thanks,
Signature · 1 line
Peter Xu
Peter Xu
reviewerPATCH 2/26 mm/alpha: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault().
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/alpha/mm/fault.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
arch/alpha/mm/fault.c +3 -5
@@ -25,6 +25,7 @@#include <linux/interrupt.h> #include <linux/extable.h> #include <linux/uaccess.h> +#include <linux/perf_event.h> extern void die_if_kernel (char *,struct pt_regs *,long ,unsigned long *);
@@ -116,6 +117,7 @@ do_page_fault(unsigned long address, unsigned long mmcsr,#endif if (user_mode (regs)) flags |=FAULT_FLAG_USER ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem); vma =find_vma (mm, address);
@@ -148,7 +150,7 @@ do_page_fault(unsigned long address, unsigned long mmcsr,/* If for any reason at all we couldn't handle the fault, make sure we exit gracefully rather than endlessly redo the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -164,10 +166,6 @@ do_page_fault(unsigned long address, unsigned long mmcsr, }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 3/26 mm/arc: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Fix PERF_COUNT_SW_PAGE_FAULTS perf event manually for page fault retries, by moving it before taking mmap_sem.
--- arch/arc/mm/fault.c | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-)
arch/arc/mm/fault.c +3 -15
@@ -106,6 +106,7 @@ void do_page_fault(unsigned long address, struct pt_regs *regs)if (write) flags |=FAULT_FLAG_WRITE ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem);
@@ -131,7 +132,7 @@ void do_page_fault(unsigned long address, struct pt_regs *regs) goto bad_area; } - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);/* Quick path to respond to signals */ if (fault_signal_pending (fault, regs)) {
@@ -156,22 +157,9 @@ void do_page_fault(unsigned long address, struct pt_regs *regs)* Major/minor page fault accounting * (in case of retry we only land here once) */ -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); - -if (likely (!(fault &VM_FAULT_ERROR ))) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , - regs, address); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , - regs, address); - } - +if (likely (!(fault &VM_FAULT_ERROR )))/* Normal return path: fault Handled Gracefully */ return ; - }if (!user_mode (regs)) goto no_context;
Signature · 7 lines
2.26.2 _______________________________________________ linux-snps-arc mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-snps-arc
Peter Xu
reviewerPATCH 4/26 mm/arm: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened. To do this, we need to pass the pt_regs pointer into __do_page_fault().
Fix PERF_COUNT_SW_PAGE_FAULTS perf event manually for page fault retries, by moving it before taking mmap_sem.
--- arch/arm/mm/fault.c | 25 ++++++------------------- 1 file changed, 6 insertions(+), 19 deletions(-)
arch/arm/mm/fault.c +6 -19
@@ -201,7 +201,8 @@ static inline bool access_error(unsigned int fsr, struct vm_area_struct *vma)static vm_fault_t __kprobes __do_page_fault (struct mm_struct *mm,unsigned long addr,unsigned int fsr, -unsigned int flags,struct task_struct *tsk) +unsigned int flags,struct task_struct *tsk, +struct pt_regs *regs) {struct vm_area_struct *vma;vm_fault_t fault;
@@ -223,7 +224,7 @@ __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr, goto out; } -return handle_mm_fault (vma, addr &PAGE_MASK , flags,NULL ); +return handle_mm_fault (vma, addr &PAGE_MASK , flags, regs); check_stack:/* Don't allow expansion below FIRST_USER_ADDRESS */
@@ -265,6 +266,8 @@ do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)if ((fsr &FSR_WRITE ) && !(fsr &FSR_CM )) flags |=FAULT_FLAG_WRITE ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, addr); +/* * As per x86, we may deadlock here. However, since the kernel only * validly references user space from well defined areas of the code,
@@ -289,7 +292,7 @@ do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)#endif } - fault =__do_page_fault (mm, addr, fsr, flags, tsk); + fault =__do_page_fault (mm, addr, fsr, flags, tsk, regs);/* If we need to retry but a fatal signal is pending, handle the * signal first. We do not need to release the mmap_sem because
@@ -301,23 +304,7 @@ do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)return 0 ; } -/* -* Major/minor page fault accounting is only done on the -* initial attempt. If we go through a retry, it is extremely -* likely that the page will be found in page cache at that point. -*/ - -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, addr);if (!(fault &VM_FAULT_ERROR ) && flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , - regs, addr); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , - regs, addr); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ; goto retry;
Signature · 7 lines
2.26.2 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Peter Xu
reviewerPATCH 5/26 mm/arm64: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened. To do this, we pass pt_regs pointer into __do_page_fault().
--- arch/arm64/mm/fault.c | 29 ++++++----------------------- 1 file changed, 6 insertions(+), 23 deletions(-)
arch/arm64/mm/fault.c +6 -23
@@ -398,7 +398,8 @@ static void do_bad_area(unsigned long addr, unsigned int esr, struct pt_regs *re#define VM_FAULT_BADACCESS 0x020000static vm_fault_t __do_page_fault (struct mm_struct *mm,unsigned long addr, -unsigned int mm_flags,unsigned long vm_flags) +unsigned int mm_flags,unsigned long vm_flags, +struct pt_regs *regs) {struct vm_area_struct *vma =find_vma (mm, addr);
@@ -422,7 +423,7 @@ static vm_fault_t __do_page_fault(struct mm_struct *mm, unsigned long addr,*/ if (!(vma->vm_flags & vm_flags))return VM_FAULT_BADACCESS ; -return handle_mm_fault (vma, addr &PAGE_MASK , mm_flags,NULL ); +return handle_mm_fault (vma, addr &PAGE_MASK , mm_flags, regs); }static bool is_el0_instruction_abort (unsigned int esr)
@@ -444,7 +445,7 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr, {const struct fault_info *inf;struct mm_struct *mm = current->mm; -vm_fault_t fault, major =0 ; +vm_fault_t fault;unsigned long vm_flags =VM_ACCESS_FLAGS ;unsigned int mm_flags =FAULT_FLAG_DEFAULT ;
@@ -510,8 +511,7 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,#endif } - fault =__do_page_fault (mm, addr, mm_flags, vm_flags); - major |= fault &VM_FAULT_MAJOR ; + fault =__do_page_fault (mm, addr, mm_flags, vm_flags, regs);/* Quick path to respond to signals */ if (fault_signal_pending (fault, regs)) {
@@ -532,25 +532,8 @@ static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,* Handle the "normal" (no error) case first. */ if (likely (!(fault & (VM_FAULT_ERROR |VM_FAULT_BADMAP | -VM_FAULT_BADACCESS )))) { -/* -* Major/minor page fault accounting is only done -* once. If we go through a retry, it is extremely -* likely that the page will be found in page cache at -* that point. -*/ -if (major) { - current->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, - addr); - }else { - current->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, - addr); - } - +VM_FAULT_BADACCESS ))))return 0 ; - }/* * If we are in kernel mode at this point, we have no context to
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 6/26 mm/csky: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/csky/mm/fault.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-)
arch/csky/mm/fault.c +1 -11
@@ -151,7 +151,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,* the fault. */ fault =handle_mm_fault (vma, address, write ?FAULT_FLAG_WRITE :0 , -NULL ); + regs);if (unlikely (fault &VM_FAULT_ERROR )) {if (fault &VM_FAULT_OOM ) goto out_of_memory;
@@ -161,16 +161,6 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write, goto bad_area;BUG (); } -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, - address); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, - address); - } -up_read (&mm->mmap_sem);return ;
Signature · 1 line
2.26.2
Guo Ren
maintainerRe: [PATCH 06/26] mm/csky: Use general page fault accounting
Quoted 17 lines · Peter Xu
Use the general page fault accounting by passing regs into
handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.--- arch/csky/mm/fault.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-)arch/csky/mm/fault.c +0
-0
arch/csky/mm/fault.c asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write, · line 154
Quoted 5 lines
arch/csky/mm/fault.c +1
-1@@ -151,7 +151,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,* the fault. */ fault =handle_mm_fault (vma, address, write ?FAULT_FLAG_WRITE :0 , -NULL ); + regs);
what's your kernel version ? (4th arg exsist ?)
/*
* If for any reason at all we couldn't handle the fault,
* make sure we exit gracefully rather than endlessly redo
* the fault.
*/
fault = handle_mm_fault(vma, address, write ? FAULT_FLAG_WRITE : 0);
if (unlikely(fault & VM_FAULT_ERROR)) {Signature · 4 lines
Best Regards Guo Ren ML: https://lore.kernel.org/linux-csky/
Peter Xu
reviewerRe: [PATCH 06/26] mm/csky: Use general page fault accounting
Quoted 24 lines · Guo Ren
Quoted 17 lines · Peter Xu
Use the general page fault accounting by passing regs into
handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.--- arch/csky/mm/fault.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-)arch/csky/mm/fault.c +0
-0arch/csky/mm/fault.c asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write, · line 154
Quoted 5 lines
arch/csky/mm/fault.c +1
-1@@ -151,7 +151,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long write,* the fault. */ fault =handle_mm_fault (vma, address, write ?FAULT_FLAG_WRITE :0 , -NULL ); + regs);what's your kernel version ? (4th arg exsist ?)
Quoted 7 lines
/*
* If for any reason at all we couldn't handle the fault,
* make sure we exit gracefully rather than endlessly redo
* the fault.
*/
fault = handle_mm_fault(vma, address, write ? FAULT_FLAG_WRITE : 0);
if (unlikely(fault & VM_FAULT_ERROR)) {Hi, Guo,
Sorry to be unclear. This patch is based on patch 1 in the same series:
https://lore.kernel.org/lkml/[email protected]/
Thanks,
Signature · 1 line
Peter Xu
Peter Xu
reviewerPATCH 7/26 mm/hexagon: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/hexagon/mm/vm_fault.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
arch/hexagon/mm/vm_fault.c +4 -5
@@ -19,6 +19,7 @@#include <linux/signal.h> #include <linux/extable.h> #include <linux/hardirq.h> +#include <linux/perf_event.h> /* * Decode of hardware exception sends us to one of several
@@ -54,6 +55,8 @@ void do_page_fault(unsigned long address, long cause, struct pt_regs *regs)if (user_mode (regs)) flags |=FAULT_FLAG_USER ; + +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem); vma =find_vma (mm, address);
@@ -89,7 +92,7 @@ void do_page_fault(unsigned long address, long cause, struct pt_regs *regs)break ; } - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -97,10 +100,6 @@ void do_page_fault(unsigned long address, long cause, struct pt_regs *regs)/* The most common case -- we are done. */ if (likely (!(fault &VM_FAULT_ERROR ))) {if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ; goto retry;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 8/26 mm/ia64: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/ia64/mm/fault.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
arch/ia64/mm/fault.c +4 -5
@@ -14,6 +14,7 @@#include <linux/kdebug.h> #include <linux/prefetch.h> #include <linux/uaccess.h> +#include <linux/perf_event.h> #include <asm/pgtable.h> #include <asm/processor.h>
@@ -101,6 +102,8 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re flags |=FAULT_FLAG_USER ;if (mask &VM_WRITE ) flags |=FAULT_FLAG_WRITE ; + +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem);
@@ -139,7 +142,7 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re* sure we exit gracefully rather than endlessly redo the * fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -162,10 +165,6 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 9/26 mm/m68k: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/m68k/mm/fault.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
arch/m68k/mm/fault.c +4 -10
@@ -12,6 +12,7 @@#include <linux/interrupt.h> #include <linux/module.h> #include <linux/uaccess.h> +#include <linux/perf_event.h> #include <asm/setup.h> #include <asm/traps.h>
@@ -85,6 +86,8 @@ int do_page_fault(struct pt_regs *regs, unsigned long address,if (user_mode (regs)) flags |=FAULT_FLAG_USER ; + +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem);
@@ -135,7 +138,7 @@ int do_page_fault(struct pt_regs *regs, unsigned long address,* the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);pr_debug ("handle_mm_fault returns %x\n" , fault);if (fault_signal_pending (fault, regs))
@@ -151,16 +154,7 @@ int do_page_fault(struct pt_regs *regs, unsigned long address,BUG (); } -/* -* Major/minor page fault accounting is only done on the -* initial attempt. If we go through a retry, it is extremely -* likely that the page will be found in page cache at that point. -*/ if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 10/26 mm/microblaze: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/microblaze/mm/fault.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
arch/microblaze/mm/fault.c +4 -5
@@ -28,6 +28,7 @@#include <linux/mman.h> #include <linux/mm.h> #include <linux/interrupt.h> +#include <linux/perf_event.h> #include <asm/page.h> #include <asm/pgtable.h>
@@ -122,6 +123,8 @@ void do_page_fault(struct pt_regs *regs, unsigned long address,if (user_mode (regs)) flags |=FAULT_FLAG_USER ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); +/* When running in the kernel we expect faults to occur only to * addresses in user space. All other faults represent errors in the * kernel and should generate an OOPS. Unfortunately, in the case of an
@@ -215,7 +218,7 @@ void do_page_fault(struct pt_regs *regs, unsigned long address,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -231,10 +234,6 @@ void do_page_fault(struct pt_regs *regs, unsigned long address, }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (unlikely (fault &VM_FAULT_MAJOR )) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 11/26 mm/mips: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Fix PERF_COUNT_SW_PAGE_FAULTS perf event manually for page fault retries, by moving it before taking mmap_sem.
--- arch/mips/mm/fault.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
arch/mips/mm/fault.c +3 -11
@@ -96,6 +96,8 @@ static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write,if (user_mode (regs)) flags |=FAULT_FLAG_USER ; + +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem); vma =find_vma (mm, address);
@@ -152,12 +154,11 @@ static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address);if (unlikely (fault &VM_FAULT_ERROR )) {if (fault &VM_FAULT_OOM ) goto out_of_memory;
@@ -168,15 +169,6 @@ static void __kprobes __do_page_fault(struct pt_regs *regs, unsigned long write,BUG (); }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , - regs, address); - tsk->maj_flt++; - }else { -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , - regs, address); - tsk->min_flt++; - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Re: [PATCH 11/26] mm/mips: Use general page fault accounting
Quoted 7 lines · Peter Xu
Use the general page fault accounting by passing regs into
handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.Fix
PERF_COUNT_SW_PAGE_FAULTSperf event manually for page fault retries, by moving it before takingmmap_sem.
Quoted 6 lines
CC Thomas Bogendoerfer <[email protected]>Signed-off-by Peter Xu <[email protected]>--- arch/mips/mm/fault.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
Thomas.
Signature · 2 lines
Crap can work. Given enough thrust pigs will fly, but it's not necessarily a good idea. [ RFC1925, 2.3 ]
Peter Xu
reviewerPATCH 12/26 mm/nds32: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Fix PERF_COUNT_SW_PAGE_FAULTS perf event manually for page fault retries, by moving it before taking mmap_sem.
--- arch/nds32/mm/fault.c | 19 +++---------------- 1 file changed, 3 insertions(+), 16 deletions(-)
arch/nds32/mm/fault.c +3 -16
@@ -122,6 +122,8 @@ void do_page_fault(unsigned long entry, unsigned long addr,if (unlikely (faulthandler_disabled () || !mm)) goto no_context; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, addr); +/* * As per x86, we may deadlock here. However, since the kernel only * validly references user space from well defined areas of the code,
@@ -207,7 +209,7 @@ void do_page_fault(unsigned long entry, unsigned long addr,* the fault. */ - fault =handle_mm_fault (vma, addr, flags,NULL ); + fault =handle_mm_fault (vma, addr, flags, regs);/* * If we need to retry but a fatal signal is pending, handle the
@@ -229,22 +231,7 @@ void do_page_fault(unsigned long entry, unsigned long addr, goto bad_area; } -/* -* Major/minor page fault accounting is only done on the initial -* attempt. If we go through a retry, it is extremely likely that the -* page will be found in page cache at that point. -*/ -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, addr);if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ , -1 , regs, addr); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN , -1 , regs, addr); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 13/26 mm/nios2: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/nios2/mm/fault.c | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-)
arch/nios2/mm/fault.c +4 -10
@@ -24,6 +24,7 @@#include <linux/mm.h> #include <linux/extable.h> #include <linux/uaccess.h> +#include <linux/perf_event.h> #include <asm/mmu_context.h> #include <asm/traps.h>
@@ -83,6 +84,8 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long cause,if (user_mode (regs)) flags |=FAULT_FLAG_USER ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); +if (!down_read_trylock (&mm->mmap_sem)) {if (!user_mode (regs) && !search_exception_tables (regs->ea)) goto bad_area_nosemaphore;
@@ -131,7 +134,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long cause,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -146,16 +149,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long cause,BUG (); } -/* -* Major/minor page fault accounting is only done on the -* initial attempt. If we go through a retry, it is extremely -* likely that the page will be found in page cache at that point. -*/ if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 14/26 mm/openrisc: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/openrisc/mm/fault.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
arch/openrisc/mm/fault.c +4 -5
@@ -15,6 +15,7 @@#include <linux/interrupt.h> #include <linux/extable.h> #include <linux/sched/signal.h> +#include <linux/perf_event.h> #include <linux/uaccess.h> #include <asm/siginfo.h>
@@ -103,6 +104,8 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long address,if (in_interrupt () || !mm) goto no_context; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); + retry:down_read (&mm->mmap_sem); vma =find_vma (mm, address);
@@ -159,7 +162,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long address,* the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -176,10 +179,6 @@ asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long address,if (flags &FAULT_FLAG_ALLOW_RETRY ) {/*RGD modeled on Cris */ -if (fault &VM_FAULT_MAJOR ) - tsk->maj_flt++; -else - tsk->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 15/26 mm/parisc: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/parisc/mm/fault.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
arch/parisc/mm/fault.c +3 -5
@@ -18,6 +18,7 @@#include <linux/extable.h> #include <linux/uaccess.h> #include <linux/hugetlb.h> +#include <linux/perf_event.h> #include <asm/traps.h>
@@ -281,6 +282,7 @@ void do_page_fault(struct pt_regs *regs, unsigned long code, acc_type =parisc_acctyp (code, regs->iir);if (acc_type &VM_WRITE ) flags |=FAULT_FLAG_WRITE ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); retry:down_read (&mm->mmap_sem); vma =find_vma_prev (mm, address, &prev_vma);
@@ -302,7 +304,7 @@ void do_page_fault(struct pt_regs *regs, unsigned long code,* fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -323,10 +325,6 @@ void do_page_fault(struct pt_regs *regs, unsigned long code,BUG (); }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) {/* * No need to up_read(&mm->mmap_sem) as we would
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 16/26 mm/powerpc: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault().
--- arch/powerpc/mm/fault.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-)
arch/powerpc/mm/fault.c +3 -8
@@ -563,7 +563,7 @@ static int __do_page_fault(struct pt_regs *regs, unsigned long address,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);#ifdef CONFIG_PPC_MEM_KEYS /*
@@ -604,14 +604,9 @@ static int __do_page_fault(struct pt_regs *regs, unsigned long address,/* * Major/minor page fault accounting. */ -if (major) { - current->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, address); +if (major)cmo_account_page_fault (); - }else { - current->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, address); - } +return 0 ; }NOKPROBE_SYMBOL (__do_page_fault);
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 17/26 mm/riscv: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/riscv/mm/fault.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-)
arch/riscv/mm/fault.c +1 -15
@@ -110,7 +110,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, addr, flags,NULL ); + fault =handle_mm_fault (vma, addr, flags, regs);/* * If we need to retry but a fatal signal is pending, handle the
@@ -128,21 +128,7 @@ asmlinkage void do_page_fault(struct pt_regs *regs)BUG (); } -/* -* Major/minor page fault accounting is only done on the -* initial attempt. If we go through a retry, it is extremely -* likely that the page will be found in page cache at that point. -*/ if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ , -1 , regs, addr); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN , -1 , regs, addr); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 18/26 mm/s390: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/s390/mm/fault.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-)
arch/s390/mm/fault.c +1 -15
@@ -479,7 +479,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs)) { fault =VM_FAULT_SIGNAL ;if (flags &FAULT_FLAG_RETRY_NOWAIT )
@@ -489,21 +489,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)if (unlikely (fault &VM_FAULT_ERROR )) goto out_up; -/* -* Major/minor page fault accounting is only done on the -* initial attempt. If we go through a retry, it is extremely -* likely that the page will be found in page cache at that point. -*/ if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , - regs, address); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , - regs, address); - }if (fault &VM_FAULT_RETRY ) {if (IS_ENABLED (CONFIG_PGSTE ) && gmap && (flags &FAULT_FLAG_RETRY_NOWAIT )) {
Signature · 1 line
2.26.2
Re: [PATCH 18/26] mm/s390: Use general page fault accounting
Quoted 27 lines · On Fri, 19 Jun 2020 12:13:35 -0400 Peter Xu <[email protected]> wrote:
Use the general page fault accounting by passing regs into
handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.CC Heiko Carstens <[email protected]>CC Vasily Gorbik <[email protected]>CC Christian Borntraeger <[email protected]>Signed-off-by Peter Xu <[email protected]>--- arch/s390/mm/fault.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-)arch/s390/mm/fault.c +1
-1@@ -479,7 +479,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs)) { fault =VM_FAULT_SIGNAL ;if (flags &FAULT_FLAG_RETRY_NOWAIT )
arch/s390/mm/fault.c static inline vm_fault_t do_exception(struct pt_regs *regs, int access) · line 490
Quoted 2 lines
arch/s390/mm/fault.c +0
-0@@ -489,21 +489,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)if (unlikely (fault &VM_FAULT_ERROR )) goto out_up;
There are two cases here where we skipped the accounting, fault_signal_pending() and VM_FAULT_ERROR, similar to other archs.
fault_signal_pending() should be ok, because that only seems to be true for fault & VM_FAULT_RETRY, in which case the new approach also skips the accounting.
But for VM_FAULT_ERROR, the new approach would do accounting, IIUC. Is that changed on purpose? See also my reply on [PATCH 01/26].
Regards,
Gerald
Peter Xu
reviewerRe: [PATCH 18/26] mm/s390: Use general page fault accounting
Quoted 36 lines · Gerald Schaefer
Quoted 27 lines · On Fri, 19 Jun 2020 12:13:35 -0400 Peter Xu <[email protected]> wrote:
Use the general page fault accounting by passing regs into
handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.CC Heiko Carstens <[email protected]>CC Vasily Gorbik <[email protected]>CC Christian Borntraeger <[email protected]>Signed-off-by Peter Xu <[email protected]>--- arch/s390/mm/fault.c | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-)arch/s390/mm/fault.c +1
-1@@ -479,7 +479,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs)) { fault =VM_FAULT_SIGNAL ;if (flags &FAULT_FLAG_RETRY_NOWAIT )arch/s390/mm/fault.c static inline vm_fault_t do_exception(struct pt_regs *regs, int access) · line 490
Quoted 2 lines
arch/s390/mm/fault.c +0
-0@@ -489,21 +489,7 @@ static inline vm_fault_t do_exception(struct pt_regs *regs, int access)if (unlikely (fault &VM_FAULT_ERROR )) goto out_up;There are two cases here where we skipped the accounting,
fault_signal_pending()andVM_FAULT_ERROR, similar to other archs.
Quoted 3 lines
fault_signal_pending()should be ok, because that only seems to be true for fault &VM_FAULT_RETRY, in which case the new approach also skips the accounting.
IMHO it's still possible to have fault_signal_pending() return true even if the fault is not with VM_FAULT_RETRY, e.g., when the signal is delivered right after the fault is correctly handled for the thread. However I hope we can avoid considering that too even if so...
Quoted 3 lines
But for
VM_FAULT_ERROR, the new approach would do accounting, IIUC. Is that changed on purpose? See also my reply on [PATCH 01/26].
(replied in the other thread)
Thanks,
Signature · 1 line
Peter Xu
Peter Xu
reviewerPATCH 19/26 mm/sh: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/sh/mm/fault.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/sh/mm/fault.c +1 -10
@@ -464,22 +464,13 @@ asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (unlikely (fault & (VM_FAULT_RETRY |VM_FAULT_ERROR )))if (mm_fault_error (regs, error_code, address, fault))return ;if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , - regs, address); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , - regs, address); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 20/26 mm/sparc32: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/sparc/mm/fault_32.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/sparc/mm/fault_32.c +1 -10
@@ -235,7 +235,7 @@ asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -251,15 +251,6 @@ asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write, }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - current->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ , -1 , regs, address); - }else { - current->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN , -1 , regs, address); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 21/26 mm/sparc64: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
--- arch/sparc/mm/fault_64.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-)
arch/sparc/mm/fault_64.c +1 -10
@@ -423,7 +423,7 @@ asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs) goto bad_area; } - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs)) goto exit_exception;
@@ -439,15 +439,6 @@ asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs) }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) { - current->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ , -1 , regs, address); - }else { - current->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN , -1 , regs, address); - }if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 22/26 mm/unicore32: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Add the missing PERF_COUNT_SW_PAGE_FAULTS perf events too. Note, the other two perf events (PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]) were done in handle_mm_fault().
--- arch/unicore32/mm/fault.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
arch/unicore32/mm/fault.c +7 -7
@@ -16,6 +16,7 @@#include <linux/page-flags.h> #include <linux/sched/signal.h> #include <linux/io.h> +#include <linux/perf_event.h> #include <asm/pgtable.h> #include <asm/tlbflush.h>
@@ -160,7 +161,8 @@ static inline bool access_error(unsigned int fsr, struct vm_area_struct *vma) }static vm_fault_t __do_pf (struct mm_struct *mm,unsigned long addr, -unsigned int fsr,unsigned int flags,struct task_struct *tsk) +unsigned int fsr,unsigned int flags, +struct task_struct *tsk,struct pt_regs *regs) {struct vm_area_struct *vma;vm_fault_t fault;
@@ -186,7 +188,7 @@ static vm_fault_t __do_pf(struct mm_struct *mm, unsigned long addr,* If for any reason at all we couldn't handle the fault, make * sure we exit gracefully rather than endlessly redo the fault. */ - fault =handle_mm_fault (vma, addr &PAGE_MASK , flags,NULL ); + fault =handle_mm_fault (vma, addr &PAGE_MASK , flags, regs);return fault; check_stack:
@@ -219,6 +221,8 @@ static int do_pf(unsigned long addr, unsigned int fsr, struct pt_regs *regs)if (!(fsr ^0x12 )) flags |=FAULT_FLAG_WRITE ; +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, addr); +/* * As per x86, we may deadlock here. However, since the kernel only * validly references user space from well defined areas of the code,
@@ -244,7 +248,7 @@ static int do_pf(unsigned long addr, unsigned int fsr, struct pt_regs *regs)#endif } - fault =__do_pf (mm, addr, fsr, flags, tsk); + fault =__do_pf (mm, addr, fsr, flags, tsk, regs);/* If we need to retry but a fatal signal is pending, handle the * signal first. We do not need to release the mmap_sem because
@@ -254,10 +258,6 @@ static int do_pf(unsigned long addr, unsigned int fsr, struct pt_regs *regs)return 0 ;if (!(fault &VM_FAULT_ERROR ) && (flags &FAULT_FLAG_ALLOW_RETRY )) { -if (fault &VM_FAULT_MAJOR ) - tsk->maj_flt++; -else - tsk->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ; goto retry;
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 23/26 mm/x86: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault().
--- arch/x86/mm/fault.c | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-)
arch/x86/mm/fault.c +2 -15
@@ -1309,7 +1309,7 @@ void do_user_addr_fault(struct pt_regs *regs,struct vm_area_struct *vma;struct task_struct *tsk;struct mm_struct *mm; -vm_fault_t fault, major =0 ; +vm_fault_t fault;unsigned int flags =FAULT_FLAG_DEFAULT ; tsk = current;
@@ -1461,8 +1461,7 @@ void do_user_addr_fault(struct pt_regs *regs,* userland). The return to userland is identified whenever * FAULT_FLAG_USER|FAULT_FLAG_KILLABLE are both set in flags. */ - fault =handle_mm_fault (vma, address, flags,NULL ); - major |= fault &VM_FAULT_MAJOR ; + fault =handle_mm_fault (vma, address, flags, regs);/* Quick path to respond to signals */ if (fault_signal_pending (fault, regs)) {
@@ -1489,18 +1488,6 @@ void do_user_addr_fault(struct pt_regs *regs,return ; } -/* -* Major/minor page fault accounting. If any of the events -* returned VM_FAULT_MAJOR, we account it as a major fault. -*/ -if (major) { - tsk->maj_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, address); - }else { - tsk->min_flt++; -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, address); - } -check_v8086_mode (regs, address, tsk); }NOKPROBE_SYMBOL (do_user_addr_fault);
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 24/26 mm/xtensa: Use general page fault accounting
In reply to Peter XuUse the general page fault accounting by passing regs into handle_mm_fault(). It naturally solve the issue of multiple page fault accounting when page fault retry happened.
Remove the PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN] perf events because it's now also done in handle_mm_fault().
Move the PERF_COUNT_SW_PAGE_FAULTS event higher before taking mmap_sem for the fault, then it'll match with the rest of the archs.
--- arch/xtensa/mm/fault.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-)
arch/xtensa/mm/fault.c +4 -11
@@ -73,6 +73,9 @@ void do_page_fault(struct pt_regs *regs)if (user_mode (regs)) flags |=FAULT_FLAG_USER ; + +perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); + retry:down_read (&mm->mmap_sem); vma =find_vma (mm, address);
@@ -108,7 +111,7 @@ void do_page_fault(struct pt_regs *regs)* make sure we exit gracefully rather than endlessly redo * the fault. */ - fault =handle_mm_fault (vma, address, flags,NULL ); + fault =handle_mm_fault (vma, address, flags, regs);if (fault_signal_pending (fault, regs))return ;
@@ -123,10 +126,6 @@ void do_page_fault(struct pt_regs *regs)BUG (); }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
@@ -140,12 +139,6 @@ void do_page_fault(struct pt_regs *regs) }up_read (&mm->mmap_sem); -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS ,1 , regs, address); -if (flags &VM_FAULT_MAJOR ) -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, address); -else -perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, address); -return ;/* Something tried to access memory that isn't in our memory map..
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 25/26 mm: Clean up the last pieces of page fault accountings
In reply to Peter XuHere're the last pieces of page fault accounting that were still done outside handle_mm_fault() where we still have regs==NULL when calling handle_mm_fault():
arch/powerpc/mm/copro_fault.c: copro_handle_mm_fault
arch/sparc/mm/fault_32.c: force_user_fault
arch/um/kernel/trap.c: handle_page_fault
mm/gup.c: faultin_page
fixup_user_fault
mm/hmm.c: hmm_vma_fault
mm/ksm.c: break_ksmSome of them has the issue of duplicated accounting for page fault retries. Some of them didn't do the accounting at all.
This patch cleans all these up by letting handle_mm_fault() to do per-task page fault accounting even if regs==NULL (though we'll still skip the perf event accountings). With that, we can safely remove all the outliers now.
There's another functional change in that now we account the page faults to the caller of gup, rather than the task_struct that passed into the gup code. More information of this can be found at [1].
After this patch, below things should never be touched again outside handle_mm_fault():
- task_struct.[maj|min]_flt
- PERF_COUNT_SW_PAGE_FAULTS_[MAJ|MIN]
[1] https://lore.kernel.org/lkml/CAHk-=wj_V2Tps2QrMn20_W0OJF9xqNh52XSGA42s-ZJ8Y+GyKw@mail.gmail.com/
--- arch/powerpc/mm/copro_fault.c | 5 ----- arch/um/kernel/trap.c | 4 ---- mm/gup.c | 13 ------------- mm/memory.c | 20 ++++++++++++-------- 4 files changed, 12 insertions(+), 30 deletions(-)
arch/powerpc/mm/copro_fault.c +0 -5
@@ -76,11 +76,6 @@ int copro_handle_mm_fault(struct mm_struct *mm, unsigned long ea,BUG (); } -if (*flt &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++; - out_unlock:up_read (&mm->mmap_sem);return ret;
arch/um/kernel/trap.c +0 -4
@@ -92,10 +92,6 @@ int handle_page_fault(unsigned long address, unsigned long ip,BUG (); }if (flags &FAULT_FLAG_ALLOW_RETRY ) { -if (fault &VM_FAULT_MAJOR ) - current->maj_flt++; -else - current->min_flt++;if (fault &VM_FAULT_RETRY ) { flags |=FAULT_FLAG_TRIED ;
mm/gup.c +0 -13
@@ -885,13 +885,6 @@ static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,BUG (); } -if (tsk) { -if (ret &VM_FAULT_MAJOR ) - tsk->maj_flt++; -else - tsk->min_flt++; - } -if (ret &VM_FAULT_RETRY ) {if (locked && !(fault_flags &FAULT_FLAG_RETRY_NOWAIT )) *locked =0 ;
@@ -1239,12 +1232,6 @@ int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm, goto retry; } -if (tsk) { -if (major) - tsk->maj_flt++; -else - tsk->min_flt++; - }return 0 ; }EXPORT_SYMBOL_GPL (fixup_user_fault);
mm/memory.c +12 -8
@@ -4350,6 +4350,8 @@ static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,/** * mm_account_fault - Do page fault accountings * @regs: the pt_regs struct pointer. When set to NULL, will skip accounting +* of perf event counters, but we'll still do the per-task accounting to +* the task who triggered this page fault. * @address: faulted address. * @major: whether this is a major fault. *
@@ -4365,16 +4367,18 @@ static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,static inline void mm_account_fault (struct pt_regs *regs,unsigned long address,bool major) { +if (major) + current->maj_flt++; +else + current->min_flt++; +if (!regs)return ; -if (major) { - current->maj_flt++; +if (major)perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MAJ ,1 , regs, address); - }else { - current->min_flt++; +else perf_sw_event (PERF_COUNT_SW_PAGE_FAULTS_MIN ,1 , regs, address); - } }/*
@@ -4450,9 +4454,9 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,* immediately previously). * * - if the fault is done for GUP, regs wil be NULL and -* no accounting will be done (but you _could_ pass in -* your own regs and it would be accounted to the thread -* doing the fault, not to the target!) +* we only do the accounting for the per thread fault +* counters who triggered the fault, and we skip the +* perf event updates. */ mm_account_fault (regs, address, (ret &VM_FAULT_MAJOR ) || (flags &FAULT_FLAG_TRIED ));
Signature · 1 line
2.26.2
Peter Xu
reviewerPATCH 26/26 mm/gup: Remove task_struct pointer for all gup code
In reply to Peter XuAfter the cleanup of page fault accounting, gup does not need to pass task_struct around any more. Remove that parameter in the whole gup stack.
--- arch/arc/kernel/process.c | 2 +- arch/s390/kvm/interrupt.c | 2 +- arch/s390/kvm/kvm-s390.c | 2 +- arch/s390/kvm/priv.c | 8 +- arch/s390/mm/gmap.c | 4 +- drivers/gpu/drm/i915/gem/i915_gem_userptr.c | 2 +- drivers/infiniband/core/umem_odp.c | 2 +- drivers/vfio/vfio_iommu_type1.c | 2 +- fs/exec.c | 2 +- include/linux/mm.h | 9 +-- kernel/events/uprobes.c | 6 +- kernel/futex.c | 2 +- mm/gup.c | 90 +++++++++------------ mm/memory.c | 2 +- mm/process_vm_access.c | 2 +- security/tomoyo/domain.c | 2 +- virt/kvm/async_pf.c | 2 +- virt/kvm/kvm_main.c | 2 +- 18 files changed, 63 insertions(+), 80 deletions(-)
arch/arc/kernel/process.c +1 -1
@@ -91,7 +91,7 @@ SYSCALL_DEFINE3(arc_usr_cmpxchg, int *, uaddr, int, expected, int, new) goto fail;down_read (¤t->mm->mmap_sem); - ret =fixup_user_fault (current, current->mm, (unsigned long ) uaddr, + ret =fixup_user_fault (current->mm, (unsigned long ) uaddr,FAULT_FLAG_WRITE ,NULL );up_read (¤t->mm->mmap_sem);
arch/s390/kvm/interrupt.c +1 -1
@@ -2768,7 +2768,7 @@ static struct page *get_map_page(struct kvm *kvm, u64 uaddr)struct page *page =NULL ;down_read (&kvm->mm->mmap_sem); -get_user_pages_remote (NULL , kvm->mm, uaddr,1 ,FOLL_WRITE , +get_user_pages_remote (kvm->mm, uaddr,1 ,FOLL_WRITE , &page,NULL ,NULL );up_read (&kvm->mm->mmap_sem);return page;
arch/s390/kvm/kvm-s390.c +1 -1
@@ -1892,7 +1892,7 @@ static long kvm_s390_set_skeys(struct kvm *kvm, struct kvm_s390_skeys *args) r =set_guest_storage_key (current->mm, hva, keys[i],0 );if (r) { - r =fixup_user_fault (current, current->mm, hva, + r =fixup_user_fault (current->mm, hva,FAULT_FLAG_WRITE , &unlocked);if (r)break ;
arch/s390/kvm/priv.c +4 -4
@@ -274,7 +274,7 @@ static int handle_iske(struct kvm_vcpu *vcpu) rc =get_guest_storage_key (current->mm, vmaddr, &key);if (rc) { - rc =fixup_user_fault (current, current->mm, vmaddr, + rc =fixup_user_fault (current->mm, vmaddr,FAULT_FLAG_WRITE , &unlocked);if (!rc) {up_read (¤t->mm->mmap_sem);
@@ -320,7 +320,7 @@ static int handle_rrbe(struct kvm_vcpu *vcpu)down_read (¤t->mm->mmap_sem); rc =reset_guest_reference_bit (current->mm, vmaddr);if (rc <0 ) { - rc =fixup_user_fault (current, current->mm, vmaddr, + rc =fixup_user_fault (current->mm, vmaddr,FAULT_FLAG_WRITE , &unlocked);if (!rc) {up_read (¤t->mm->mmap_sem);
@@ -391,7 +391,7 @@ static int handle_sske(struct kvm_vcpu *vcpu) m3 & SSKE_MC);if (rc <0 ) { - rc =fixup_user_fault (current, current->mm, vmaddr, + rc =fixup_user_fault (current->mm, vmaddr,FAULT_FLAG_WRITE , &unlocked); rc = !rc ? -EAGAIN : rc; }
@@ -1095,7 +1095,7 @@ static int handle_pfmf(struct kvm_vcpu *vcpu) rc =cond_set_guest_storage_key (current->mm, vmaddr, key,NULL , nq, mr, mc);if (rc <0 ) { - rc =fixup_user_fault (current, current->mm, vmaddr, + rc =fixup_user_fault (current->mm, vmaddr,FAULT_FLAG_WRITE , &unlocked); rc = !rc ? -EAGAIN : rc; }
arch/s390/mm/gmap.c +2 -2
@@ -649,7 +649,7 @@ int gmap_fault(struct gmap *gmap, unsigned long gaddr, rc = vmaddr; goto out_up; } -if (fixup_user_fault (current, gmap->mm, vmaddr, fault_flags, +if (fixup_user_fault (gmap->mm, vmaddr, fault_flags, &unlocked)) { rc = -EFAULT ; goto out_up;
@@ -879,7 +879,7 @@ static int gmap_pte_op_fixup(struct gmap *gmap, unsigned long gaddr,BUG_ON (gmap_is_shadow (gmap)); fault_flags = (prot ==PROT_WRITE ) ?FAULT_FLAG_WRITE :0 ; -if (fixup_user_fault (current, mm, vmaddr, fault_flags, &unlocked)) +if (fixup_user_fault (mm, vmaddr, fault_flags, &unlocked))return -EFAULT ;if (unlocked)/* lost mmap_sem, caller has to retry __gmap_translate */
drivers/gpu/drm/i915/gem/i915_gem_userptr.c +1 -1
@@ -472,7 +472,7 @@ __i915_gem_userptr_get_pages_worker(struct work_struct *_work) locked =1 ; } ret = get_user_pages_remote - (work->task, mm, + (mm, obj->userptr.ptr + pinned * PAGE_SIZE, npages - pinned, flags,
drivers/infiniband/core/umem_odp.c +1 -1
@@ -437,7 +437,7 @@ int ib_umem_odp_map_dma_pages(struct ib_umem_odp *umem_odp, u64 user_virt,* complex (and doesn't gain us much performance in most use * cases). */ - npages =get_user_pages_remote (owning_process, owning_mm, + npages =get_user_pages_remote (owning_mm, user_virt, gup_num_pages, flags, local_page_list,NULL ,NULL );up_read (&owning_mm->mmap_sem);
drivers/vfio/vfio_iommu_type1.c +1 -1
@@ -329,7 +329,7 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned long vaddr, flags |=FOLL_WRITE ;down_read (&mm->mmap_sem); - ret =pin_user_pages_remote (NULL , mm, vaddr,1 , flags |FOLL_LONGTERM , + ret =pin_user_pages_remote (mm, vaddr,1 , flags |FOLL_LONGTERM , page,NULL ,NULL );if (ret ==1 ) { *pfn =page_to_pfn (page[0 ]);
fs/exec.c +1 -1
@@ -213,7 +213,7 @@ static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,* We are doing an exec(). 'current' is the process * doing the exec and bprm->mm is the new process's mm. */ - ret =get_user_pages_remote (current, bprm->mm, pos,1 , gup_flags, + ret =get_user_pages_remote (bprm->mm, pos,1 , gup_flags, &page,NULL ,NULL );if (ret <=0 )return NULL ;
include/linux/mm.h +4 -5
@@ -1655,7 +1655,7 @@ int invalidate_inode_page(struct page *page);extern vm_fault_t handle_mm_fault (struct vm_area_struct *vma,unsigned long address,unsigned int flags,struct pt_regs *regs); -extern int fixup_user_fault (struct task_struct *tsk,struct mm_struct *mm, +extern int fixup_user_fault (struct mm_struct *mm,unsigned long address,unsigned int fault_flags,bool *unlocked); void unmap_mapping_pages(struct address_space *mapping,
@@ -1671,8 +1671,7 @@ static inline vm_fault_t handle_mm_fault(struct vm_area_struct *vma,BUG ();return VM_FAULT_SIGBUS ; } -static inline int fixup_user_fault (struct task_struct *tsk, -struct mm_struct *mm,unsigned long address, +static inline int fixup_user_fault (struct mm_struct *mm,unsigned long address,unsigned int fault_flags,bool *unlocked) {/* should never happen if there's no MMU */
@@ -1698,11 +1697,11 @@ extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,extern int __access_remote_vm (struct task_struct *tsk,struct mm_struct *mm,unsigned long addr,void *buf,int len,unsigned int gup_flags); -long get_user_pages_remote (struct task_struct *tsk,struct mm_struct *mm, +long get_user_pages_remote (struct mm_struct *mm,unsigned long start,unsigned long nr_pages,unsigned int gup_flags,struct page **pages,struct vm_area_struct **vmas,int *locked); -long pin_user_pages_remote (struct task_struct *tsk,struct mm_struct *mm, +long pin_user_pages_remote (struct mm_struct *mm,unsigned long start,unsigned long nr_pages,unsigned int gup_flags,struct page **pages,struct vm_area_struct **vmas,int *locked);
kernel/events/uprobes.c +3 -3
@@ -382,7 +382,7 @@ __update_ref_ctr(struct mm_struct *mm, unsigned long vaddr, short d)if (!vaddr || !d)return -EINVAL ; - ret =get_user_pages_remote (NULL , mm, vaddr,1 , + ret =get_user_pages_remote (mm, vaddr,1 ,FOLL_WRITE , &page, &vma,NULL );if (unlikely (ret <=0 )) {/*
@@ -483,7 +483,7 @@ int uprobe_write_opcode(struct arch_uprobe *auprobe, struct mm_struct *mm,if (is_register) gup_flags |=FOLL_SPLIT_PMD ;/* Read the page with vaddr into memory */ - ret =get_user_pages_remote (NULL , mm, vaddr,1 , gup_flags, + ret =get_user_pages_remote (mm, vaddr,1 , gup_flags, &old_page, &vma,NULL );if (ret <=0 )return ret;
@@ -2027,7 +2027,7 @@ static int is_trap_at_addr(struct mm_struct *mm, unsigned long vaddr)* but we treat this as a 'remote' access since it is * essentially a kernel access to the memory. */ - result =get_user_pages_remote (NULL , mm, vaddr,1 ,FOLL_FORCE , &page, + result =get_user_pages_remote (mm, vaddr,1 ,FOLL_FORCE , &page,NULL ,NULL );if (result <0 )return result;
kernel/futex.c +1 -1
@@ -696,7 +696,7 @@ static int fault_in_user_writeable(u32 __user *uaddr)int ret;down_read (&mm->mmap_sem); - ret =fixup_user_fault (current, mm, (unsigned long )uaddr, + ret =fixup_user_fault (mm, (unsigned long )uaddr,FAULT_FLAG_WRITE ,NULL );up_read (&mm->mmap_sem);
mm/gup.c +37 -53
325 lines not on this page · raw message
mm/memory.c +1 -1
@@ -4742,7 +4742,7 @@ int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,void *maddr;struct page *page =NULL ; - ret =get_user_pages_remote (tsk, mm, addr,1 , + ret =get_user_pages_remote (mm, addr,1 , gup_flags, &page, &vma,NULL );if (ret <=0 ) {#ifndef CONFIG_HAVE_IOREMAP_PROT
mm/process_vm_access.c +1 -1
@@ -105,7 +105,7 @@ static int process_vm_rw_single_vec(unsigned long addr,* current/current->mm */ down_read (&mm->mmap_sem); - pinned_pages =pin_user_pages_remote (task, mm, pa, pinned_pages, + pinned_pages =pin_user_pages_remote (mm, pa, pinned_pages, flags, process_pages,NULL , &locked);if (locked)
security/tomoyo/domain.c +1 -1
@@ -914,7 +914,7 @@ bool tomoyo_dump_page(struct linux_binprm *bprm, unsigned long pos,* (represented by bprm). 'current' is the process doing * the execve(). */ -if (get_user_pages_remote (current, bprm->mm, pos,1 , +if (get_user_pages_remote (bprm->mm, pos,1 ,FOLL_FORCE , &page,NULL ,NULL ) <=0 )return false;#else
virt/kvm/async_pf.c +1 -1
@@ -60,7 +60,7 @@ static void async_pf_execute(struct work_struct *work)* access remotely. */ down_read (&mm->mmap_sem); -get_user_pages_remote (NULL , mm, addr,1 ,FOLL_WRITE ,NULL ,NULL , +get_user_pages_remote (mm, addr,1 ,FOLL_WRITE ,NULL ,NULL , &locked);if (locked)up_read (&mm->mmap_sem);
virt/kvm/kvm_main.c +1 -1
@@ -1829,7 +1829,7 @@ static int hva_to_pfn_remapped(struct vm_area_struct *vma,* not call the fault handler, so do it here. */ bool unlocked = false; - r =fixup_user_fault (current, current->mm, addr, + r =fixup_user_fault (current->mm, addr, (write_fault ?FAULT_FLAG_WRITE :0 ), &unlocked);if (unlocked)
Signature · 1 line
2.26.2