| /* 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(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 */ |