Release 4.18 include/linux/sched/mm.h

Directory: include/linux/sched
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_SCHED_MM_H

#define _LINUX_SCHED_MM_H

#include <linux/kernel.h>
#include <linux/atomic.h>
#include <linux/sched.h>
#include <linux/mm_types.h>
#include <linux/gfp.h>
#include <linux/sync_core.h>

/*
 * Routines for handling mm_structs
 */
extern struct mm_struct *mm_alloc(void);

/**
 * mmgrab() - Pin a &struct mm_struct.
 * @mm: The &struct mm_struct to pin.
 *
 * Make sure that @mm will not get freed even after the owning task
 * exits. This doesn't guarantee that the associated address space
 * will still exist later on and mmget_not_zero() has to be used before
 * accessing it.
 *
 * This is a preferred way to to pin @mm for a longer/unbounded amount
 * of time.
 *
 * Use mmdrop() to release the reference acquired by mmgrab().
 *
 * See also <Documentation/vm/active_mm.rst> for an in-depth explanation
 * of &mm_struct.mm_count vs &mm_struct.mm_users.
 */


static inline void mmgrab(struct mm_struct *mm)
{
	atomic_inc(&mm->mm_count);
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%

extern void __mmdrop(struct mm_struct *mm);



static inline void mmdrop(struct mm_struct *mm)
{
	/*
         * The implicit full barrier implied by atomic_dec_and_test() is
         * required by the membarrier system call before returning to
         * user-space, after storing to rq->curr.
         */
	if (unlikely(atomic_dec_and_test(&mm->mm_count)))
		__mmdrop(mm);
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%

/**
 * mmget() - Pin the address space associated with a &struct mm_struct.
 * @mm: The address space to pin.
 *
 * Make sure that the address space of the given &struct mm_struct doesn't
 * go away. This does not protect against parts of the address space being
 * modified or freed, however.
 *
 * Never use this function to pin this address space for an
 * unbounded/indefinite amount of time.
 *
 * Use mmput() to release the reference acquired by mmget().
 *
 * See also <Documentation/vm/active_mm.rst> for an in-depth explanation
 * of &mm_struct.mm_count vs &mm_struct.mm_users.
 */


static inline void mmget(struct mm_struct *mm)
{
	atomic_inc(&mm->mm_users);
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%



static inline bool mmget_not_zero(struct mm_struct *mm)
{
	return atomic_inc_not_zero(&mm->mm_users);
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

/* mmput gets rid of the mappings and all user-space */
extern void mmput(struct mm_struct *);
#ifdef CONFIG_MMU
/* same as above but performs the slow path from the async context. Can
 * be called from the atomic context as well
 */
void mmput_async(struct mm_struct *);
#endif

/* Grab a reference to a task's mm, if it is not already going away */
extern struct mm_struct *get_task_mm(struct task_struct *task);
/*
 * Grab a reference to a task's mm, if it is not already going away
 * and ptrace_may_access with the mode parameter passed to it
 * succeeds.
 */
extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
/* Remove the current tasks stale references to the old mm_struct */
extern void mm_release(struct task_struct *, struct mm_struct *);

#ifdef CONFIG_MEMCG
extern void mm_update_next_owner(struct mm_struct *mm);
#else


static inline void mm_update_next_owner(struct mm_struct *mm)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%

#endif /* CONFIG_MEMCG */

#ifdef CONFIG_MMU
extern void arch_pick_mmap_layout(struct mm_struct *mm,
				  struct rlimit *rlim_stack);
extern unsigned long
arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
		       unsigned long, unsigned long);
extern unsigned long
arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
			  unsigned long len, unsigned long pgoff,
			  unsigned long flags);
#else


static inline void arch_pick_mmap_layout(struct mm_struct *mm,
					 struct rlimit *rlim_stack) {}
Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 11 68.75% 1 50.00%
Kees Cook 5 31.25% 1 50.00%
Total 16 100.00% 2 100.00%

#endif



static inline bool in_vfork(struct task_struct *tsk)
{
	bool ret;

	/*
         * need RCU to access ->real_parent if CLONE_VM was used along with
         * CLONE_PARENT.
         *
         * We check real_parent->mm == tsk->mm because CLONE_VFORK does not
         * imply CLONE_VM
         *
         * CLONE_VFORK can be used with CLONE_PARENT/CLONE_THREAD and thus
         * ->real_parent is not necessarily the task doing vfork(), so in
         * theory we can't rely on task_lock() if we want to dereference it.
         *
         * And in this case we can't trust the real_parent->mm == tsk->mm
         * check, it can be false negative. But we do not care, if init or
         * another oom-unkillable task does this it should blame itself.
         */
	rcu_read_lock();
	ret = tsk->vfork_done && tsk->real_parent->mm == tsk->mm;
	rcu_read_unlock();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%

/*
 * Applies per-task gfp context to the given allocation flags.
 * PF_MEMALLOC_NOIO implies GFP_NOIO
 * PF_MEMALLOC_NOFS implies GFP_NOFS
 */


static inline gfp_t current_gfp_context(gfp_t flags)
{
	/*
         * NOIO implies both NOIO and NOFS and it is a weaker context
         * so always make sure it makes precendence
         */
	if (unlikely(current->flags & PF_MEMALLOC_NOIO))
		flags &= ~(__GFP_IO | __GFP_FS);
	else if (unlikely(current->flags & PF_MEMALLOC_NOFS))
		flags &= ~__GFP_FS;
	return flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 32 62.75% 1 50.00%
Michal Hocko 19 37.25% 1 50.00%
Total 51 100.00% 2 100.00%

#ifdef CONFIG_LOCKDEP
extern void __fs_reclaim_acquire(void);
extern void __fs_reclaim_release(void);
extern void fs_reclaim_acquire(gfp_t gfp_mask);
extern void fs_reclaim_release(gfp_t gfp_mask);
#else


static inline void __fs_reclaim_acquire(void) { }
Contributors
Person Tokens Prop Commits CommitProp
Omar Sandoval 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline void __fs_reclaim_release(void) { }
Contributors
Person Tokens Prop Commits CommitProp
Omar Sandoval 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline void fs_reclaim_acquire(gfp_t gfp_mask) { }
Contributors
Person Tokens Prop Commits CommitProp
Peter Zijlstra 9 100.00% 1 100.00%
Total 9 100.00% 1 100.00%



static inline void fs_reclaim_release(gfp_t gfp_mask) { }
Contributors
Person Tokens Prop Commits CommitProp
Peter Zijlstra 9 100.00% 1 100.00%
Total 9 100.00% 1 100.00%

#endif

/**
 * memalloc_noio_save - Marks implicit GFP_NOIO allocation scope.
 *
 * This functions marks the beginning of the GFP_NOIO allocation scope.
 * All further allocations will implicitly drop __GFP_IO flag and so
 * they are safe for the IO critical section from the allocation recursion
 * point of view. Use memalloc_noio_restore to end the scope with flags
 * returned by this function.
 *
 * This function is safe to be used from any context.
 */


static inline unsigned int memalloc_noio_save(void)
{
	unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
	current->flags |= PF_MEMALLOC_NOIO;
	return flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%

/**
 * memalloc_noio_restore - Ends the implicit GFP_NOIO scope.
 * @flags: Flags to restore.
 *
 * Ends the implicit GFP_NOIO scope started by memalloc_noio_save function.
 * Always make sure that that the given flags is the return value from the
 * pairing memalloc_noio_save call.
 */


static inline void memalloc_noio_restore(unsigned int flags)
{
	current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%

/**
 * memalloc_nofs_save - Marks implicit GFP_NOFS allocation scope.
 *
 * This functions marks the beginning of the GFP_NOFS allocation scope.
 * All further allocations will implicitly drop __GFP_FS flag and so
 * they are safe for the FS critical section from the allocation recursion
 * point of view. Use memalloc_nofs_restore to end the scope with flags
 * returned by this function.
 *
 * This function is safe to be used from any context.
 */


static inline unsigned int memalloc_nofs_save(void)
{
	unsigned int flags = current->flags & PF_MEMALLOC_NOFS;
	current->flags |= PF_MEMALLOC_NOFS;
	return flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Michal Hocko 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%

/**
 * memalloc_nofs_restore - Ends the implicit GFP_NOFS scope.
 * @flags: Flags to restore.
 *
 * Ends the implicit GFP_NOFS scope started by memalloc_nofs_save function.
 * Always make sure that that the given flags is the return value from the
 * pairing memalloc_nofs_save call.
 */


static inline void memalloc_nofs_restore(unsigned int flags)
{
	current->flags = (current->flags & ~PF_MEMALLOC_NOFS) | flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Michal Hocko 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static inline unsigned int memalloc_noreclaim_save(void)
{
	unsigned int flags = current->flags & PF_MEMALLOC;
	current->flags |= PF_MEMALLOC;
	return flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Vlastimil Babka 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



static inline void memalloc_noreclaim_restore(unsigned int flags)
{
	current->flags = (current->flags & ~PF_MEMALLOC) | flags;
}

Contributors
Person Tokens Prop Commits CommitProp
Vlastimil Babka 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%

#ifdef CONFIG_MEMBARRIER

enum {
	
MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY		= (1U << 0),
	
MEMBARRIER_STATE_PRIVATE_EXPEDITED			= (1U << 1),
	
MEMBARRIER_STATE_GLOBAL_EXPEDITED_READY			= (1U << 2),
	
MEMBARRIER_STATE_GLOBAL_EXPEDITED			= (1U << 3),
	
MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE_READY	= (1U << 4),
	
MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE		= (1U << 5),
};


enum {
	
MEMBARRIER_FLAG_SYNC_CORE	= (1U << 0),
};

#ifdef CONFIG_ARCH_HAS_MEMBARRIER_CALLBACKS
#include <asm/membarrier.h>
#endif



static inline void membarrier_mm_sync_core_before_usermode(struct mm_struct *mm)
{
	if (likely(!(atomic_read(&mm->membarrier_state) &
		     MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE)))
		return;
	sync_core_before_usermode();
}

Contributors
Person Tokens Prop Commits CommitProp
Mathieu Desnoyers 34 100.00% 1 100.00%
Total 34 100.00% 1 100.00%



static inline void membarrier_execve(struct task_struct *t)
{
	atomic_set(&t->mm->membarrier_state, 0);
}
Contributors
Person Tokens Prop Commits CommitProp
Mathieu Desnoyers 24 100.00% 1 100.00%
Total 24 100.00% 1 100.00%

#else
#ifdef CONFIG_ARCH_HAS_MEMBARRIER_CALLBACKS


static inline void membarrier_arch_switch_mm(struct mm_struct *prev,
					     struct mm_struct *next,
					     struct task_struct *tsk)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Mathieu Desnoyers 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

#endif


static inline void membarrier_execve(struct task_struct *t)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Mathieu Desnoyers 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%



static inline void membarrier_mm_sync_core_before_usermode(struct mm_struct *mm)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Mathieu Desnoyers 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%

#endif

#endif /* _LINUX_SCHED_MM_H */
Overall Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 391 46.44% 8 34.78%
Mathieu Desnoyers 186 22.09% 4 17.39%
Michal Hocko 79 9.38% 2 8.70%
Vlastimil Babka 55 6.53% 1 4.35%
Peter Zijlstra 41 4.87% 1 4.35%
Andrew Morton 33 3.92% 2 8.70%
Omar Sandoval 30 3.56% 1 4.35%
Sherry Yang 14 1.66% 1 4.35%
Kees Cook 10 1.19% 1 4.35%
Mike Rapoport 2 0.24% 1 4.35%
Greg Kroah-Hartman 1 0.12% 1 4.35%
Total 842 100.00% 23 100.00%
Directory: include/linux/sched

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Ingo Molnar	20	100.00%	1	100.00%
Total	20	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.18 include/linux/sched/mm.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
