Release 4.12 include/linux/freezer.h

Directory: include/linux
/* Freezer declarations */

#ifndef FREEZER_H_INCLUDED

#define FREEZER_H_INCLUDED

#include <linux/debug_locks.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/atomic.h>

#ifdef CONFIG_FREEZER
extern atomic_t system_freezing_cnt;	/* nr of freezing conds in effect */
extern bool pm_freezing;		/* PM freezing in effect */
extern bool pm_nosig_freezing;		/* PM nosig freezing in effect */

/*
 * Timeout for stopping processes
 */
extern unsigned int freeze_timeout_msecs;

/*
 * Check if a process has been frozen
 */


static inline bool frozen(struct task_struct *p)
{
	return p->flags & PF_FROZEN;
}

Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 18 94.74% 1 50.00%
Tejun Heo 1 5.26% 1 50.00%
Total 19 100.00% 2 100.00%

extern bool freezing_slow_path(struct task_struct *p);

/*
 * Check if there is a request to freeze a process
 */


static inline bool freezing(struct task_struct *p)
{
	if (likely(!atomic_read(&system_freezing_cnt)))
		return false;
	return freezing_slow_path(p);
}

Contributors
Person Tokens Prop Commits CommitProp
Tejun Heo 18 54.55% 1 33.33%
Nigel Cunningham 11 33.33% 1 33.33%
Rafael J. Wysocki 4 12.12% 1 33.33%
Total 33 100.00% 3 100.00%

/* Takes and releases task alloc lock using task_lock() */
extern void __thaw_task(struct task_struct *t);

extern bool __refrigerator(bool check_kthr_stop);
extern int freeze_processes(void);
extern int freeze_kernel_threads(void);
extern void thaw_processes(void);
extern void thaw_kernel_threads(void);

/*
 * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
 * If try_to_freeze causes a lockdep warning it means the caller may deadlock
 */


static inline bool try_to_freeze_unsafe(void)
{
	might_sleep();
	if (likely(!freezing(current)))
		return false;
	return __refrigerator(false);
}

Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 18 56.25% 1 25.00%
Tejun Heo 13 40.62% 2 50.00%
Colin Cross 1 3.12% 1 25.00%
Total 32 100.00% 4 100.00%



static inline bool try_to_freeze(void)
{
	if (!(current->flags & PF_NOFREEZE))
		debug_check_no_locks_held();
	return try_to_freeze_unsafe();
}

Contributors
Person Tokens Prop Commits CommitProp
Mandeep Singh Baines 14 51.85% 1 50.00%
Colin Cross 13 48.15% 1 50.00%
Total 27 100.00% 2 100.00%

extern bool freeze_task(struct task_struct *p);
extern bool set_freezable(void);

#ifdef CONFIG_CGROUP_FREEZER
extern bool cgroup_freezing(struct task_struct *task);
#else /* !CONFIG_CGROUP_FREEZER */


static inline bool cgroup_freezing(struct task_struct *task)
{
	return false;
}
Contributors
Person Tokens Prop Commits CommitProp
Matt Helsley 12 80.00% 1 50.00%
Tejun Heo 3 20.00% 1 50.00%
Total 15 100.00% 2 100.00%

#endif /* !CONFIG_CGROUP_FREEZER */

/*
 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
 * calls wait_for_completion(&vfork) and reset right after it returns from this
 * function.  Next, the parent should call try_to_freeze() to freeze itself
 * appropriately in case the child has exited before the freezing of tasks is
 * complete.  However, we don't want kernel threads to be frozen in unexpected
 * places, so we allow them to block freeze_processes() instead or to set
 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
 * parent won't really block freeze_processes(), since ____call_usermodehelper()
 * (the child) does a little before exec/exit and it can't be frozen before
 * waking up the parent.
 */


/**
 * freezer_do_not_count - tell freezer to ignore %current
 *
 * Tell freezers to ignore the current task when determining whether the
 * target frozen state is reached.  IOW, the current task will be
 * considered frozen enough by freezers.
 *
 * The caller shouldn't do anything which isn't allowed for a frozen task
 * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
 * wrap a scheduling operation and nothing much else.
 */


static inline void freezer_do_not_count(void)
{
	current->flags |= PF_FREEZER_SKIP;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%

/**
 * freezer_count - tell freezer to stop ignoring %current
 *
 * Undo freezer_do_not_count().  It tells freezers that %current should be
 * considered again and tries to freeze if freezing condition is already in
 * effect.
 */


static inline void freezer_count(void)
{
	current->flags &= ~PF_FREEZER_SKIP;
	/*
         * If freezing is in progress, the following paired with smp_mb()
         * in freezer_should_skip() ensures that either we see %true
         * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
         */
	smp_mb();
	try_to_freeze();
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 17 73.91% 1 33.33%
Tejun Heo 4 17.39% 1 33.33%
Nigel Cunningham 2 8.70% 1 33.33%
Total 23 100.00% 3 100.00%

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */


static inline void freezer_count_unsafe(void)
{
	current->flags &= ~PF_FREEZER_SKIP;
	smp_mb();
	try_to_freeze_unsafe();
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%

/**
 * freezer_should_skip - whether to skip a task when determining frozen
 *                       state is reached
 * @p: task in quesion
 *
 * This function is used by freezers after establishing %true freezing() to
 * test whether a task should be skipped when determining the target frozen
 * state is reached.  IOW, if this function returns %true, @p is considered
 * frozen enough.
 */


static inline bool freezer_should_skip(struct task_struct *p)
{
	/*
         * The following smp_mb() paired with the one in freezer_count()
         * ensures that either freezer_count() sees %true freezing() or we
         * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
         * impossible for a task to slip frozen state testing after
         * clearing %PF_FREEZER_SKIP.
         */
	smp_mb();
	return p->flags & PF_FREEZER_SKIP;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 17 73.91% 1 33.33%
Tejun Heo 5 21.74% 1 33.33%
Nigel Cunningham 1 4.35% 1 33.33%
Total 23 100.00% 3 100.00%

/*
 * These functions are intended to be used whenever you want allow a sleeping
 * task to be frozen. Note that neither return any clear indication of
 * whether a freeze event happened while in this function.
 */

/* Like schedule(), but should not block the freezer. */


static inline void freezable_schedule(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count();
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 17 94.44% 1 50.00%
Jeff Layton 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */


static inline void freezable_schedule_unsafe(void)
{
	freezer_do_not_count();
	schedule();
	freezer_count_unsafe();
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%

/*
 * Like freezable_schedule_timeout(), but should not block the freezer.  Do not
 * call this with locks held.
 */


static inline long freezable_schedule_timeout(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout(timeout);
	freezer_count();
	return __retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%

/*
 * Like schedule_timeout_interruptible(), but should not block the freezer.  Do not
 * call this with locks held.
 */


static inline long freezable_schedule_timeout_interruptible(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_interruptible(timeout);
	freezer_count();
	return __retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%

/* Like schedule_timeout_killable(), but should not block the freezer. */


static inline long freezable_schedule_timeout_killable(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_killable(timeout);
	freezer_count();
	return __retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 25 86.21% 1 50.00%
Jeff Layton 4 13.79% 1 50.00%
Total 29 100.00% 2 100.00%

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */


static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
{
	long __retval;
	freezer_do_not_count();
	__retval = schedule_timeout_killable(timeout);
	freezer_count_unsafe();
	return __retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 29 100.00% 2 100.00%
Total 29 100.00% 2 100.00%

/*
 * Like schedule_hrtimeout_range(), but should not block the freezer.  Do not
 * call this with locks held.
 */


static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
		u64 delta, const enum hrtimer_mode mode)
{
	int __retval;
	freezer_do_not_count();
	__retval = schedule_hrtimeout_range(expires, delta, mode);
	freezer_count();
	return __retval;
}

Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 41 97.62% 1 50.00%
John Stultz 1 2.38% 1 50.00%
Total 42 100.00% 2 100.00%

/*
 * Freezer-friendly wrappers around wait_event_interruptible(),
 * wait_event_killable() and wait_event_interruptible_timeout(), originally
 * defined in <linux/wait.h>
 */

/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */

#define wait_event_freezekillable_unsafe(wq, condition)			\
({                                                                      \
        int __retval;                                                   \
        freezer_do_not_count();                                         \
        __retval = wait_event_killable(wq, (condition));                \
        freezer_count_unsafe();                                         \
        __retval;                                                       \
})

#else /* !CONFIG_FREEZER */


static inline bool frozen(struct task_struct *p) { return false; }
Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 13 86.67% 1 50.00%
Tejun Heo 2 13.33% 1 50.00%
Total 15 100.00% 2 100.00%



static inline bool freezing(struct task_struct *p) { return false; }
Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 13 86.67% 1 50.00%
Tejun Heo 2 13.33% 1 50.00%
Total 15 100.00% 2 100.00%



static inline void __thaw_task(struct task_struct *t) {}

Contributors
Person Tokens Prop Commits CommitProp
Stephen Rothwell 11 100.00% 1 100.00%
Total 11 100.00% 1 100.00%



static inline bool __refrigerator(bool check_kthr_stop) { return false; }
Contributors
Person Tokens Prop Commits CommitProp
Tejun Heo 9 69.23% 2 66.67%
Nigel Cunningham 4 30.77% 1 33.33%
Total 13 100.00% 3 100.00%



static inline int freeze_processes(void) { return -ENOSYS; }
Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 9 69.23% 1 50.00%
Rafael J. Wysocki 4 30.77% 1 50.00%
Total 13 100.00% 2 100.00%



static inline int freeze_kernel_threads(void) { return -ENOSYS; }
Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 11 84.62% 1 50.00%
Nigel Cunningham 2 15.38% 1 50.00%
Total 13 100.00% 2 100.00%



static inline void thaw_processes(void) {}
Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline void thaw_kernel_threads(void) {}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline bool try_to_freeze_nowarn(void) { return false; }
Contributors
Person Tokens Prop Commits CommitProp
Li Haifeng 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%



static inline bool try_to_freeze(void) { return false; }

Contributors
Person Tokens Prop Commits CommitProp
Nigel Cunningham 10 83.33% 1 50.00%
Tejun Heo 2 16.67% 1 50.00%
Total 12 100.00% 2 100.00%



static inline void freezer_do_not_count(void) {}
Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline void freezer_count(void) {}
Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%



static inline int freezer_should_skip(struct task_struct *p) { return 0; }
Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%



static inline void set_freezable(void) {}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 8 100.00% 1 100.00%
Total 8 100.00% 1 100.00%


#define freezable_schedule()  schedule()


#define freezable_schedule_unsafe()  schedule()


#define freezable_schedule_timeout(timeout)  schedule_timeout(timeout)


#define freezable_schedule_timeout_interruptible(timeout)		\
	schedule_timeout_interruptible(timeout)


#define freezable_schedule_timeout_killable(timeout)			\
	schedule_timeout_killable(timeout)


#define freezable_schedule_timeout_killable_unsafe(timeout)		\
	schedule_timeout_killable(timeout)


#define freezable_schedule_hrtimeout_range(expires, delta, mode)	\
	schedule_hrtimeout_range(expires, delta, mode)


#define wait_event_freezekillable_unsafe(wq, condition)			\
		wait_event_killable(wq, condition)

#endif /* !CONFIG_FREEZER */

#endif	/* FREEZER_H_INCLUDED */
Overall Contributors
Person Tokens Prop Commits CommitProp
Colin Cross 293 36.72% 4 12.12%
Rafael J. Wysocki 147 18.42% 7 21.21%
Nigel Cunningham 135 16.92% 2 6.06%
Tejun Heo 101 12.66% 9 27.27%
Matt Helsley 50 6.27% 2 6.06%
Jeff Layton 21 2.63% 2 6.06%
Mandeep Singh Baines 17 2.13% 1 3.03%
Li Haifeng 12 1.50% 1 3.03%
Stephen Rothwell 11 1.38% 1 3.03%
Li Fei 6 0.75% 1 3.03%
Randy Dunlap 3 0.38% 1 3.03%
Srivatsa S. Bhat 1 0.13% 1 3.03%
John Stultz 1 0.13% 1 3.03%
Total 798 100.00% 33 100.00%
Directory: include/linux

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
Nigel Cunningham	18	94.74%	1	50.00%
Tejun Heo	1	5.26%	1	50.00%
Total	19	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.12 include/linux/freezer.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

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
