mm: move tlb_flush_pending inline helpers to mm_inline.h (36090def) · Commits · EulixOS / Software / Kernel

arch/x86/include/asm/pgtable.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -752,7 +752,7 @@ static inline bool pte_accessible(struct mm_struct *mm, pte_t a)
		return true;

		if ((pte_flags(a) & _PAGE_PROTNONE) &&
		mm_tlb_flush_pending(mm))
		atomic_read(&mm->tlb_flush_pending))
		return true;

		return false;

include/linux/mm.h

+0 −45

Original line number	Diff line number	Diff line
		@@ -424,51 +424,6 @@ extern unsigned int kobjsize(const void *objp);
		*/
		extern pgprot_t protection_map[16];

		/**
		* enum fault_flag - Fault flag definitions.
		* @FAULT_FLAG_WRITE: Fault was a write fault.
		* @FAULT_FLAG_MKWRITE: Fault was mkwrite of existing PTE.
		* @FAULT_FLAG_ALLOW_RETRY: Allow to retry the fault if blocked.
		* @FAULT_FLAG_RETRY_NOWAIT: Don't drop mmap_lock and wait when retrying.
		* @FAULT_FLAG_KILLABLE: The fault task is in SIGKILL killable region.
		* @FAULT_FLAG_TRIED: The fault has been tried once.
		* @FAULT_FLAG_USER: The fault originated in userspace.
		* @FAULT_FLAG_REMOTE: The fault is not for current task/mm.
		* @FAULT_FLAG_INSTRUCTION: The fault was during an instruction fetch.
		* @FAULT_FLAG_INTERRUPTIBLE: The fault can be interrupted by non-fatal signals.
		*
		* About @FAULT_FLAG_ALLOW_RETRY and @FAULT_FLAG_TRIED: we can specify
		* whether we would allow page faults to retry by specifying these two
		* fault flags correctly. Currently there can be three legal combinations:
		*
		* (a) ALLOW_RETRY and !TRIED: this means the page fault allows retry, and
		* this is the first try
		*
		* (b) ALLOW_RETRY and TRIED: this means the page fault allows retry, and
		* we've already tried at least once
		*
		* (c) !ALLOW_RETRY and !TRIED: this means the page fault does not allow retry
		*
		* The unlisted combination (!ALLOW_RETRY && TRIED) is illegal and should never
		* be used. Note that page faults can be allowed to retry for multiple times,
		* in which case we'll have an initial fault with flags (a) then later on
		* continuous faults with flags (b). We should always try to detect pending
		* signals before a retry to make sure the continuous page faults can still be
		* interrupted if necessary.
		*/
		enum fault_flag {
		FAULT_FLAG_WRITE = 1 << 0,
		FAULT_FLAG_MKWRITE = 1 << 1,
		FAULT_FLAG_ALLOW_RETRY = 1 << 2,
		FAULT_FLAG_RETRY_NOWAIT = 1 << 3,
		FAULT_FLAG_KILLABLE = 1 << 4,
		FAULT_FLAG_TRIED = 1 << 5,
		FAULT_FLAG_USER = 1 << 6,
		FAULT_FLAG_REMOTE = 1 << 7,
		FAULT_FLAG_INSTRUCTION = 1 << 8,
		FAULT_FLAG_INTERRUPTIBLE = 1 << 9,
		};

		/*
		* The default fault flags that should be used by most of the
		* arch-specific page fault handlers.

include/linux/mm_inline.h

+86 −0

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		#ifndef LINUX_MM_INLINE_H
		#define LINUX_MM_INLINE_H

		#include <linux/atomic.h>
		#include <linux/huge_mm.h>
		#include <linux/swap.h>
		#include <linux/string.h>
		@@ -185,4 +186,89 @@ static inline bool is_same_vma_anon_name(struct vm_area_struct *vma,
		}
		#endif /* CONFIG_ANON_VMA_NAME */

		static inline void init_tlb_flush_pending(struct mm_struct *mm)
		{
		atomic_set(&mm->tlb_flush_pending, 0);
		}

		static inline void inc_tlb_flush_pending(struct mm_struct *mm)
		{
		atomic_inc(&mm->tlb_flush_pending);
		/*
		* The only time this value is relevant is when there are indeed pages
		* to flush. And we'll only flush pages after changing them, which
		* requires the PTL.
		*
		* So the ordering here is:
		*
		* atomic_inc(&mm->tlb_flush_pending);
		* spin_lock(&ptl);
		* ...
		* set_pte_at();
		* spin_unlock(&ptl);
		*
		* spin_lock(&ptl)
		* mm_tlb_flush_pending();
		* ....
		* spin_unlock(&ptl);
		*
		* flush_tlb_range();
		* atomic_dec(&mm->tlb_flush_pending);
		*
		* Where the increment if constrained by the PTL unlock, it thus
		* ensures that the increment is visible if the PTE modification is
		* visible. After all, if there is no PTE modification, nobody cares
		* about TLB flushes either.
		*
		* This very much relies on users (mm_tlb_flush_pending() and
		* mm_tlb_flush_nested()) only caring about _specific_ PTEs (and
		* therefore specific PTLs), because with SPLIT_PTE_PTLOCKS and RCpc
		* locks (PPC) the unlock of one doesn't order against the lock of
		* another PTL.
		*
		* The decrement is ordered by the flush_tlb_range(), such that
		* mm_tlb_flush_pending() will not return false unless all flushes have
		* completed.
		*/
		}

		static inline void dec_tlb_flush_pending(struct mm_struct *mm)
		{
		/*
		* See inc_tlb_flush_pending().
		*
		* This cannot be smp_mb__before_atomic() because smp_mb() simply does
		* not order against TLB invalidate completion, which is what we need.
		*
		* Therefore we must rely on tlb_flush_*() to guarantee order.
		*/
		atomic_dec(&mm->tlb_flush_pending);
		}

		static inline bool mm_tlb_flush_pending(struct mm_struct *mm)
		{
		/*
		* Must be called after having acquired the PTL; orders against that
		* PTLs release and therefore ensures that if we observe the modified
		* PTE we must also observe the increment from inc_tlb_flush_pending().
		*
		* That is, it only guarantees to return true if there is a flush
		* pending for _this_ PTL.
		*/
		return atomic_read(&mm->tlb_flush_pending);
		}

		static inline bool mm_tlb_flush_nested(struct mm_struct *mm)
		{
		/*
		* Similar to mm_tlb_flush_pending(), we must have acquired the PTL
		* for which there is a TLB flush pending in order to guarantee
		* we've seen both that PTE modification and the increment.
		*
		* (no requirement on actually still holding the PTL, that is irrelevant)
		*/
		return atomic_read(&mm->tlb_flush_pending) > 1;
		}


		#endif

include/linux/mm_types.h

+45 −84

Original line number	Diff line number	Diff line
		@@ -692,90 +692,6 @@ extern void tlb_gather_mmu(struct mmu_gather tlb, struct mm_struct mm);
		extern void tlb_gather_mmu_fullmm(struct mmu_gather tlb, struct mm_struct mm);
		extern void tlb_finish_mmu(struct mmu_gather *tlb);

		static inline void init_tlb_flush_pending(struct mm_struct *mm)
		{
		atomic_set(&mm->tlb_flush_pending, 0);
		}

		static inline void inc_tlb_flush_pending(struct mm_struct *mm)
		{
		atomic_inc(&mm->tlb_flush_pending);
		/*
		* The only time this value is relevant is when there are indeed pages
		* to flush. And we'll only flush pages after changing them, which
		* requires the PTL.
		*
		* So the ordering here is:
		*
		* atomic_inc(&mm->tlb_flush_pending);
		* spin_lock(&ptl);
		* ...
		* set_pte_at();
		* spin_unlock(&ptl);
		*
		* spin_lock(&ptl)
		* mm_tlb_flush_pending();
		* ....
		* spin_unlock(&ptl);
		*
		* flush_tlb_range();
		* atomic_dec(&mm->tlb_flush_pending);
		*
		* Where the increment if constrained by the PTL unlock, it thus
		* ensures that the increment is visible if the PTE modification is
		* visible. After all, if there is no PTE modification, nobody cares
		* about TLB flushes either.
		*
		* This very much relies on users (mm_tlb_flush_pending() and
		* mm_tlb_flush_nested()) only caring about _specific_ PTEs (and
		* therefore specific PTLs), because with SPLIT_PTE_PTLOCKS and RCpc
		* locks (PPC) the unlock of one doesn't order against the lock of
		* another PTL.
		*
		* The decrement is ordered by the flush_tlb_range(), such that
		* mm_tlb_flush_pending() will not return false unless all flushes have
		* completed.
		*/
		}

		static inline void dec_tlb_flush_pending(struct mm_struct *mm)
		{
		/*
		* See inc_tlb_flush_pending().
		*
		* This cannot be smp_mb__before_atomic() because smp_mb() simply does
		* not order against TLB invalidate completion, which is what we need.
		*
		* Therefore we must rely on tlb_flush_*() to guarantee order.
		*/
		atomic_dec(&mm->tlb_flush_pending);
		}

		static inline bool mm_tlb_flush_pending(struct mm_struct *mm)
		{
		/*
		* Must be called after having acquired the PTL; orders against that
		* PTLs release and therefore ensures that if we observe the modified
		* PTE we must also observe the increment from inc_tlb_flush_pending().
		*
		* That is, it only guarantees to return true if there is a flush
		* pending for _this_ PTL.
		*/
		return atomic_read(&mm->tlb_flush_pending);
		}

		static inline bool mm_tlb_flush_nested(struct mm_struct *mm)
		{
		/*
		* Similar to mm_tlb_flush_pending(), we must have acquired the PTL
		* for which there is a TLB flush pending in order to guarantee
		* we've seen both that PTE modification and the increment.
		*
		* (no requirement on actually still holding the PTL, that is irrelevant)
		*/
		return atomic_read(&mm->tlb_flush_pending) > 1;
		}

		struct vm_fault;

		/**
		@@ -890,4 +806,49 @@ typedef struct {
		unsigned long val;
		} swp_entry_t;

		/**
		* enum fault_flag - Fault flag definitions.
		* @FAULT_FLAG_WRITE: Fault was a write fault.
		* @FAULT_FLAG_MKWRITE: Fault was mkwrite of existing PTE.
		* @FAULT_FLAG_ALLOW_RETRY: Allow to retry the fault if blocked.
		* @FAULT_FLAG_RETRY_NOWAIT: Don't drop mmap_lock and wait when retrying.
		* @FAULT_FLAG_KILLABLE: The fault task is in SIGKILL killable region.
		* @FAULT_FLAG_TRIED: The fault has been tried once.
		* @FAULT_FLAG_USER: The fault originated in userspace.
		* @FAULT_FLAG_REMOTE: The fault is not for current task/mm.
		* @FAULT_FLAG_INSTRUCTION: The fault was during an instruction fetch.
		* @FAULT_FLAG_INTERRUPTIBLE: The fault can be interrupted by non-fatal signals.
		*
		* About @FAULT_FLAG_ALLOW_RETRY and @FAULT_FLAG_TRIED: we can specify
		* whether we would allow page faults to retry by specifying these two
		* fault flags correctly. Currently there can be three legal combinations:
		*
		* (a) ALLOW_RETRY and !TRIED: this means the page fault allows retry, and
		* this is the first try
		*
		* (b) ALLOW_RETRY and TRIED: this means the page fault allows retry, and
		* we've already tried at least once
		*
		* (c) !ALLOW_RETRY and !TRIED: this means the page fault does not allow retry
		*
		* The unlisted combination (!ALLOW_RETRY && TRIED) is illegal and should never
		* be used. Note that page faults can be allowed to retry for multiple times,
		* in which case we'll have an initial fault with flags (a) then later on
		* continuous faults with flags (b). We should always try to detect pending
		* signals before a retry to make sure the continuous page faults can still be
		* interrupted if necessary.
		*/
		enum fault_flag {
		FAULT_FLAG_WRITE = 1 << 0,
		FAULT_FLAG_MKWRITE = 1 << 1,
		FAULT_FLAG_ALLOW_RETRY = 1 << 2,
		FAULT_FLAG_RETRY_NOWAIT = 1 << 3,
		FAULT_FLAG_KILLABLE = 1 << 4,
		FAULT_FLAG_TRIED = 1 << 5,
		FAULT_FLAG_USER = 1 << 6,
		FAULT_FLAG_REMOTE = 1 << 7,
		FAULT_FLAG_INSTRUCTION = 1 << 8,
		FAULT_FLAG_INTERRUPTIBLE = 1 << 9,
		};

		#endif /* _LINUX_MM_TYPES_H */

mm/ksm.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,7 @@

		#include <linux/errno.h>
		#include <linux/mm.h>
		#include <linux/mm_inline.h>
		#include <linux/fs.h>
		#include <linux/mman.h>
		#include <linux/sched.h>