1 /* Freezer declarations */
3 #ifndef FREEZER_H_INCLUDED
4 #define FREEZER_H_INCLUDED
6 #include <linux/debug_locks.h>
7 #include <linux/sched.h>
8 #include <linux/wait.h>
9 #include <linux/atomic.h>
12 extern atomic_t system_freezing_cnt; /* nr of freezing conds in effect */
13 extern bool pm_freezing; /* PM freezing in effect */
14 extern bool pm_nosig_freezing; /* PM nosig freezing in effect */
17 * Timeout for stopping processes
19 extern unsigned int freeze_timeout_msecs;
22 * Check if a process has been frozen
24 static inline bool frozen(struct task_struct *p)
26 return p->flags & PF_FROZEN;
29 extern bool freezing_slow_path(struct task_struct *p);
32 * Check if there is a request to freeze a process
34 static inline bool freezing(struct task_struct *p)
36 if (likely(!atomic_read(&system_freezing_cnt)))
38 return freezing_slow_path(p);
41 /* Takes and releases task alloc lock using task_lock() */
42 extern void __thaw_task(struct task_struct *t);
44 extern bool __refrigerator(bool check_kthr_stop);
45 extern int freeze_processes(void);
46 extern int freeze_kernel_threads(void);
47 extern void thaw_processes(void);
48 extern void thaw_kernel_threads(void);
51 * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
52 * If try_to_freeze causes a lockdep warning it means the caller may deadlock
54 static inline bool try_to_freeze_unsafe(void)
57 if (likely(!freezing(current)))
59 return __refrigerator(false);
62 static inline bool try_to_freeze(void)
64 if (!(current->flags & PF_NOFREEZE))
65 debug_check_no_locks_held();
66 return try_to_freeze_unsafe();
69 extern bool freeze_task(struct task_struct *p);
70 extern bool set_freezable(void);
72 #ifdef CONFIG_CGROUP_FREEZER
73 extern bool cgroup_freezing(struct task_struct *task);
74 #else /* !CONFIG_CGROUP_FREEZER */
75 static inline bool cgroup_freezing(struct task_struct *task)
79 #endif /* !CONFIG_CGROUP_FREEZER */
82 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
83 * calls wait_for_completion(&vfork) and reset right after it returns from this
84 * function. Next, the parent should call try_to_freeze() to freeze itself
85 * appropriately in case the child has exited before the freezing of tasks is
86 * complete. However, we don't want kernel threads to be frozen in unexpected
87 * places, so we allow them to block freeze_processes() instead or to set
88 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
89 * parent won't really block freeze_processes(), since ____call_usermodehelper()
90 * (the child) does a little before exec/exit and it can't be frozen before
91 * waking up the parent.
96 * freezer_do_not_count - tell freezer to ignore %current
98 * Tell freezers to ignore the current task when determining whether the
99 * target frozen state is reached. IOW, the current task will be
100 * considered frozen enough by freezers.
102 * The caller shouldn't do anything which isn't allowed for a frozen task
103 * until freezer_cont() is called. Usually, freezer[_do_not]_count() pair
104 * wrap a scheduling operation and nothing much else.
106 static inline void freezer_do_not_count(void)
108 current->flags |= PF_FREEZER_SKIP;
112 * freezer_count - tell freezer to stop ignoring %current
114 * Undo freezer_do_not_count(). It tells freezers that %current should be
115 * considered again and tries to freeze if freezing condition is already in
118 static inline void freezer_count(void)
120 current->flags &= ~PF_FREEZER_SKIP;
122 * If freezing is in progress, the following paired with smp_mb()
123 * in freezer_should_skip() ensures that either we see %true
124 * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
130 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
131 static inline void freezer_count_unsafe(void)
133 current->flags &= ~PF_FREEZER_SKIP;
135 try_to_freeze_unsafe();
139 * freezer_should_skip - whether to skip a task when determining frozen
141 * @p: task in quesion
143 * This function is used by freezers after establishing %true freezing() to
144 * test whether a task should be skipped when determining the target frozen
145 * state is reached. IOW, if this function returns %true, @p is considered
148 static inline bool freezer_should_skip(struct task_struct *p)
151 * The following smp_mb() paired with the one in freezer_count()
152 * ensures that either freezer_count() sees %true freezing() or we
153 * see cleared %PF_FREEZER_SKIP and return %false. This makes it
154 * impossible for a task to slip frozen state testing after
155 * clearing %PF_FREEZER_SKIP.
158 return p->flags & PF_FREEZER_SKIP;
162 * These functions are intended to be used whenever you want allow a sleeping
163 * task to be frozen. Note that neither return any clear indication of
164 * whether a freeze event happened while in this function.
167 /* Like schedule(), but should not block the freezer. */
168 static inline void freezable_schedule(void)
170 freezer_do_not_count();
175 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
176 static inline void freezable_schedule_unsafe(void)
178 freezer_do_not_count();
180 freezer_count_unsafe();
183 /* Like schedule_timeout_killable(), but should not block the freezer. */
184 static inline long freezable_schedule_timeout_killable(long timeout)
187 freezer_do_not_count();
188 __retval = schedule_timeout_killable(timeout);
193 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
194 static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
197 freezer_do_not_count();
198 __retval = schedule_timeout_killable(timeout);
199 freezer_count_unsafe();
204 * Freezer-friendly wrappers around wait_event_interruptible(),
205 * wait_event_killable() and wait_event_interruptible_timeout(), originally
206 * defined in <linux/wait.h>
209 #define wait_event_freezekillable(wq, condition) \
212 freezer_do_not_count(); \
213 __retval = wait_event_killable(wq, (condition)); \
218 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
219 #define wait_event_freezekillable_unsafe(wq, condition) \
222 freezer_do_not_count(); \
223 __retval = wait_event_killable(wq, (condition)); \
224 freezer_count_unsafe(); \
228 #define wait_event_freezable(wq, condition) \
231 freezer_do_not_count(); \
232 __retval = wait_event_interruptible(wq, (condition)); \
237 #define wait_event_freezable_timeout(wq, condition, timeout) \
239 long __retval = timeout; \
240 freezer_do_not_count(); \
241 __retval = wait_event_interruptible_timeout(wq, (condition), \
247 #else /* !CONFIG_FREEZER */
248 static inline bool frozen(struct task_struct *p) { return false; }
249 static inline bool freezing(struct task_struct *p) { return false; }
250 static inline void __thaw_task(struct task_struct *t) {}
252 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
253 static inline int freeze_processes(void) { return -ENOSYS; }
254 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
255 static inline void thaw_processes(void) {}
256 static inline void thaw_kernel_threads(void) {}
258 static inline bool try_to_freeze_nowarn(void) { return false; }
259 static inline bool try_to_freeze(void) { return false; }
261 static inline void freezer_do_not_count(void) {}
262 static inline void freezer_count(void) {}
263 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
264 static inline void set_freezable(void) {}
266 #define freezable_schedule() schedule()
268 #define freezable_schedule_unsafe() schedule()
270 #define freezable_schedule_timeout_killable(timeout) \
271 schedule_timeout_killable(timeout)
273 #define freezable_schedule_timeout_killable_unsafe(timeout) \
274 schedule_timeout_killable(timeout)
276 #define wait_event_freezable(wq, condition) \
277 wait_event_interruptible(wq, condition)
279 #define wait_event_freezable_timeout(wq, condition, timeout) \
280 wait_event_interruptible_timeout(wq, condition, timeout)
282 #define wait_event_freezekillable(wq, condition) \
283 wait_event_killable(wq, condition)
285 #define wait_event_freezekillable_unsafe(wq, condition) \
286 wait_event_killable(wq, condition)
288 #endif /* !CONFIG_FREEZER */
290 #endif /* FREEZER_H_INCLUDED */