1 /* Freezer declarations */
3 #ifndef FREEZER_H_INCLUDED
4 #define FREEZER_H_INCLUDED
6 #include <linux/sched.h>
7 #include <linux/wait.h>
8 #include <linux/atomic.h>
11 extern atomic_t system_freezing_cnt; /* nr of freezing conds in effect */
12 extern bool pm_freezing; /* PM freezing in effect */
13 extern bool pm_nosig_freezing; /* PM nosig freezing in effect */
16 * Timeout for stopping processes
18 extern unsigned int freeze_timeout_msecs;
21 * Check if a process has been frozen
23 static inline bool frozen(struct task_struct *p)
25 return p->flags & PF_FROZEN;
28 extern bool freezing_slow_path(struct task_struct *p);
31 * Check if there is a request to freeze a process
33 static inline bool freezing(struct task_struct *p)
35 if (likely(!atomic_read(&system_freezing_cnt)))
37 return freezing_slow_path(p);
40 /* Takes and releases task alloc lock using task_lock() */
41 extern void __thaw_task(struct task_struct *t);
43 extern bool __refrigerator(bool check_kthr_stop);
44 extern int freeze_processes(void);
45 extern int freeze_kernel_threads(void);
46 extern void thaw_processes(void);
47 extern void thaw_kernel_threads(void);
50 * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION
51 * If try_to_freeze causes a lockdep warning it means the caller may deadlock
53 static inline bool try_to_freeze_unsafe(void)
56 if (likely(!freezing(current)))
58 return __refrigerator(false);
61 static inline bool try_to_freeze(void)
63 return try_to_freeze_unsafe();
66 extern bool freeze_task(struct task_struct *p);
67 extern bool set_freezable(void);
69 #ifdef CONFIG_CGROUP_FREEZER
70 extern bool cgroup_freezing(struct task_struct *task);
71 #else /* !CONFIG_CGROUP_FREEZER */
72 static inline bool cgroup_freezing(struct task_struct *task)
76 #endif /* !CONFIG_CGROUP_FREEZER */
79 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
80 * calls wait_for_completion(&vfork) and reset right after it returns from this
81 * function. Next, the parent should call try_to_freeze() to freeze itself
82 * appropriately in case the child has exited before the freezing of tasks is
83 * complete. However, we don't want kernel threads to be frozen in unexpected
84 * places, so we allow them to block freeze_processes() instead or to set
85 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
86 * parent won't really block freeze_processes(), since ____call_usermodehelper()
87 * (the child) does a little before exec/exit and it can't be frozen before
88 * waking up the parent.
93 * freezer_do_not_count - tell freezer to ignore %current
95 * Tell freezers to ignore the current task when determining whether the
96 * target frozen state is reached. IOW, the current task will be
97 * considered frozen enough by freezers.
99 * The caller shouldn't do anything which isn't allowed for a frozen task
100 * until freezer_cont() is called. Usually, freezer[_do_not]_count() pair
101 * wrap a scheduling operation and nothing much else.
103 static inline void freezer_do_not_count(void)
105 current->flags |= PF_FREEZER_SKIP;
109 * freezer_count - tell freezer to stop ignoring %current
111 * Undo freezer_do_not_count(). It tells freezers that %current should be
112 * considered again and tries to freeze if freezing condition is already in
115 static inline void freezer_count(void)
117 current->flags &= ~PF_FREEZER_SKIP;
119 * If freezing is in progress, the following paired with smp_mb()
120 * in freezer_should_skip() ensures that either we see %true
121 * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
127 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
128 static inline void freezer_count_unsafe(void)
130 current->flags &= ~PF_FREEZER_SKIP;
132 try_to_freeze_unsafe();
136 * freezer_should_skip - whether to skip a task when determining frozen
138 * @p: task in quesion
140 * This function is used by freezers after establishing %true freezing() to
141 * test whether a task should be skipped when determining the target frozen
142 * state is reached. IOW, if this function returns %true, @p is considered
145 static inline bool freezer_should_skip(struct task_struct *p)
148 * The following smp_mb() paired with the one in freezer_count()
149 * ensures that either freezer_count() sees %true freezing() or we
150 * see cleared %PF_FREEZER_SKIP and return %false. This makes it
151 * impossible for a task to slip frozen state testing after
152 * clearing %PF_FREEZER_SKIP.
155 return p->flags & PF_FREEZER_SKIP;
159 * These macros are intended to be used whenever you want allow a sleeping
160 * task to be frozen. Note that neither return any clear indication of
161 * whether a freeze event happened while in this function.
164 /* Like schedule(), but should not block the freezer. */
165 #define freezable_schedule() \
167 freezer_do_not_count(); \
172 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
173 #define freezable_schedule_unsafe() \
175 freezer_do_not_count(); \
177 freezer_count_unsafe(); \
180 /* Like schedule_timeout_killable(), but should not block the freezer. */
181 #define freezable_schedule_timeout_killable(timeout) \
184 freezer_do_not_count(); \
185 __retval = schedule_timeout_killable(timeout); \
190 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
191 #define freezable_schedule_timeout_killable_unsafe(timeout) \
194 freezer_do_not_count(); \
195 __retval = schedule_timeout_killable(timeout); \
196 freezer_count_unsafe(); \
201 * Freezer-friendly wrappers around wait_event_interruptible(),
202 * wait_event_killable() and wait_event_interruptible_timeout(), originally
203 * defined in <linux/wait.h>
206 #define wait_event_freezekillable(wq, condition) \
209 freezer_do_not_count(); \
210 __retval = wait_event_killable(wq, (condition)); \
215 #define wait_event_freezable(wq, condition) \
219 __retval = wait_event_interruptible(wq, \
220 (condition) || freezing(current)); \
221 if (__retval || (condition)) \
228 #define wait_event_freezable_timeout(wq, condition, timeout) \
230 long __retval = timeout; \
232 __retval = wait_event_interruptible_timeout(wq, \
233 (condition) || freezing(current), \
235 if (__retval <= 0 || (condition)) \
242 #else /* !CONFIG_FREEZER */
243 static inline bool frozen(struct task_struct *p) { return false; }
244 static inline bool freezing(struct task_struct *p) { return false; }
245 static inline void __thaw_task(struct task_struct *t) {}
247 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
248 static inline int freeze_processes(void) { return -ENOSYS; }
249 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
250 static inline void thaw_processes(void) {}
251 static inline void thaw_kernel_threads(void) {}
253 static inline bool try_to_freeze_nowarn(void) { return false; }
254 static inline bool try_to_freeze(void) { return false; }
256 static inline void freezer_do_not_count(void) {}
257 static inline void freezer_count(void) {}
258 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
259 static inline void set_freezable(void) {}
261 #define freezable_schedule() schedule()
263 #define freezable_schedule_unsafe() schedule()
265 #define freezable_schedule_timeout_killable(timeout) \
266 schedule_timeout_killable(timeout)
268 #define freezable_schedule_timeout_killable_unsafe(timeout) \
269 schedule_timeout_killable(timeout)
271 #define wait_event_freezable(wq, condition) \
272 wait_event_interruptible(wq, condition)
274 #define wait_event_freezable_timeout(wq, condition, timeout) \
275 wait_event_interruptible_timeout(wq, condition, timeout)
277 #define wait_event_freezekillable(wq, condition) \
278 wait_event_killable(wq, condition)
280 #endif /* !CONFIG_FREEZER */
282 #endif /* FREEZER_H_INCLUDED */