Contributors: 21
Author Tokens Token Proportion Commits Commit Proportion
Tejun Heo 79 20.10% 9 21.95%
Matt Helsley 52 13.23% 2 4.88%
Nigel Cunningham 51 12.98% 1 2.44%
Rafael J. Wysocki 46 11.70% 6 14.63%
Patrick Mochel 37 9.41% 2 4.88%
Peter Zijlstra 20 5.09% 1 2.44%
Pavel Machek 19 4.83% 1 2.44%
Mandeep Singh Baines 17 4.33% 1 2.44%
Andrew Morton 14 3.56% 3 7.32%
Christoph Lameter 13 3.31% 1 2.44%
Linus Torvalds (pre-git) 10 2.54% 2 4.88%
zhongjinji 8 2.04% 1 2.44%
Li Fei 6 1.53% 1 2.44%
Nicholas Piggin 4 1.02% 1 2.44%
Stephen Rothwell 4 1.02% 1 2.44%
Colin Cross 3 0.76% 1 2.44%
Randy Dunlap 3 0.76% 1 2.44%
Michael Hunold 3 0.76% 2 4.88%
Ingo Molnar 2 0.51% 2 4.88%
David S. Miller 1 0.25% 1 2.44%
Greg Kroah-Hartman 1 0.25% 1 2.44%
Total 393 41 


/* SPDX-License-Identifier: GPL-2.0 */
/* 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>
#include <linux/jump_label.h>

#ifdef CONFIG_FREEZER
DECLARE_STATIC_KEY_FALSE(freezer_active);

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 for PM or cgroup1 freezer. Note that
 * cgroup2 freezer uses the job control mechanism and does not interact with
 * the PM freezer.
 */
extern bool frozen(struct task_struct *p);

extern bool freezing_slow_path(struct task_struct *p);

/*
 * Check if there is a request to freeze a task from PM or cgroup1 freezer.
 * Note that cgroup2 freezer uses the job control mechanism and does not
 * interact with the PM freezer.
 */
static inline bool freezing(struct task_struct *p)
{
	if (static_branch_unlikely(&freezer_active))
		return freezing_slow_path(p);

	return false;
}

/* 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);
extern void thaw_process(struct task_struct *p);

static inline bool try_to_freeze(void)
{
	might_sleep();
	if (likely(!freezing(current)))
		return false;
	if (!(current->flags & PF_NOFREEZE))
		debug_check_no_locks_held();
	return __refrigerator(false);
}

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

#ifdef CONFIG_CGROUP_FREEZER
extern bool cgroup1_freezing(struct task_struct *task);
#else /* !CONFIG_CGROUP_FREEZER */
static inline bool cgroup1_freezing(struct task_struct *task)
{
	return false;
}
#endif /* !CONFIG_CGROUP_FREEZER */

#else /* !CONFIG_FREEZER */
static inline bool frozen(struct task_struct *p) { return false; }
static inline bool freezing(struct task_struct *p) { return false; }
static inline void __thaw_task(struct task_struct *t) {}

static inline bool __refrigerator(bool check_kthr_stop) { return false; }
static inline int freeze_processes(void) { return -ENOSYS; }
static inline int freeze_kernel_threads(void) { return -ENOSYS; }
static inline void thaw_processes(void) {}
static inline void thaw_kernel_threads(void) {}
static inline void thaw_process(struct task_struct *p) {}

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

static inline void set_freezable(void) {}

#endif /* !CONFIG_FREEZER */

#endif	/* FREEZER_H_INCLUDED */