mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
9.0 KiB
316 lines
9.0 KiB
/* 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> |
|
|
|
#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; |
|
} |
|
|
|
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); |
|
} |
|
|
|
/* 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); |
|
} |
|
|
|
static inline bool try_to_freeze(void) |
|
{ |
|
if (!(current->flags & PF_NOFREEZE)) |
|
debug_check_no_locks_held(); |
|
return try_to_freeze_unsafe(); |
|
} |
|
|
|
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; |
|
} |
|
#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; |
|
} |
|
|
|
/** |
|
* 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(); |
|
} |
|
|
|
/* 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(); |
|
} |
|
|
|
/** |
|
* 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; |
|
} |
|
|
|
/* |
|
* 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(); |
|
} |
|
|
|
/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ |
|
static inline void freezable_schedule_unsafe(void) |
|
{ |
|
freezer_do_not_count(); |
|
schedule(); |
|
freezer_count_unsafe(); |
|
} |
|
|
|
/* |
|
* Like 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; |
|
} |
|
|
|
/* |
|
* 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; |
|
} |
|
|
|
/* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ |
|
static inline long freezable_schedule_timeout_interruptible_unsafe(long timeout) |
|
{ |
|
long __retval; |
|
|
|
freezer_do_not_count(); |
|
__retval = schedule_timeout_interruptible(timeout); |
|
freezer_count_unsafe(); |
|
return __retval; |
|
} |
|
|
|
/* 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; |
|
} |
|
|
|
/* 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; |
|
} |
|
|
|
/* |
|
* 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; |
|
} |
|
|
|
/* |
|
* 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; } |
|
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 bool try_to_freeze_nowarn(void) { return false; } |
|
static inline bool try_to_freeze(void) { return false; } |
|
|
|
static inline void freezer_do_not_count(void) {} |
|
static inline void freezer_count(void) {} |
|
static inline int freezer_should_skip(struct task_struct *p) { return 0; } |
|
static inline void set_freezable(void) {} |
|
|
|
#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_interruptible_unsafe(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 */
|
|
|