1 /* Freezer declarations */
2
3 #ifndef FREEZER_H_INCLUDED
4 #define FREEZER_H_INCLUDED
5
6 #include <linux/debug_locks.h>
7 #include <linux/sched.h>
8 #include <linux/wait.h>
9 #include <linux/atomic.h>
10
11 #ifdef CONFIG_FREEZER
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 */
15
16 /*
17 * Timeout for stopping processes
18 */
19 extern unsigned int freeze_timeout_msecs;
20
21 /*
22 * Check if a process has been frozen
23 */
frozen(struct task_struct * p)24 static inline bool frozen(struct task_struct *p)
25 {
26 return p->flags & PF_FROZEN;
27 }
28
29 extern bool freezing_slow_path(struct task_struct *p);
30
31 /*
32 * Check if there is a request to freeze a process
33 */
freezing(struct task_struct * p)34 static inline bool freezing(struct task_struct *p)
35 {
36 if (likely(!atomic_read(&system_freezing_cnt)))
37 return false;
38 return freezing_slow_path(p);
39 }
40
41 /* Takes and releases task alloc lock using task_lock() */
42 extern void __thaw_task(struct task_struct *t);
43
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);
49
50 /*
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
53 */
try_to_freeze_unsafe(void)54 static inline bool try_to_freeze_unsafe(void)
55 {
56 might_sleep();
57 if (likely(!freezing(current)))
58 return false;
59 return __refrigerator(false);
60 }
61
try_to_freeze(void)62 static inline bool try_to_freeze(void)
63 {
64 if (!(current->flags & PF_NOFREEZE))
65 debug_check_no_locks_held();
66 return try_to_freeze_unsafe();
67 }
68
69 extern bool freeze_task(struct task_struct *p);
70 extern bool set_freezable(void);
71
72 #ifdef CONFIG_CGROUP_FREEZER
73 extern bool cgroup_freezing(struct task_struct *task);
74 #else /* !CONFIG_CGROUP_FREEZER */
cgroup_freezing(struct task_struct * task)75 static inline bool cgroup_freezing(struct task_struct *task)
76 {
77 return false;
78 }
79 #endif /* !CONFIG_CGROUP_FREEZER */
80
81 /*
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.
92 */
93
94
95 /**
96 * freezer_do_not_count - tell freezer to ignore %current
97 *
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.
101 *
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.
105 */
freezer_do_not_count(void)106 static inline void freezer_do_not_count(void)
107 {
108 current->flags |= PF_FREEZER_SKIP;
109 }
110
111 /**
112 * freezer_count - tell freezer to stop ignoring %current
113 *
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
116 * effect.
117 */
freezer_count(void)118 static inline void freezer_count(void)
119 {
120 current->flags &= ~PF_FREEZER_SKIP;
121 /*
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.
125 */
126 smp_mb();
127 try_to_freeze();
128 }
129
130 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
freezer_count_unsafe(void)131 static inline void freezer_count_unsafe(void)
132 {
133 current->flags &= ~PF_FREEZER_SKIP;
134 smp_mb();
135 try_to_freeze_unsafe();
136 }
137
138 /**
139 * freezer_should_skip - whether to skip a task when determining frozen
140 * state is reached
141 * @p: task in quesion
142 *
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
146 * frozen enough.
147 */
freezer_should_skip(struct task_struct * p)148 static inline bool freezer_should_skip(struct task_struct *p)
149 {
150 /*
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.
156 */
157 smp_mb();
158 return p->flags & PF_FREEZER_SKIP;
159 }
160
161 /*
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.
165 */
166
167 /* Like schedule(), but should not block the freezer. */
freezable_schedule(void)168 static inline void freezable_schedule(void)
169 {
170 freezer_do_not_count();
171 schedule();
172 freezer_count();
173 }
174
175 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
freezable_schedule_unsafe(void)176 static inline void freezable_schedule_unsafe(void)
177 {
178 freezer_do_not_count();
179 schedule();
180 freezer_count_unsafe();
181 }
182
183 /*
184 * Like freezable_schedule_timeout(), but should not block the freezer. Do not
185 * call this with locks held.
186 */
freezable_schedule_timeout(long timeout)187 static inline long freezable_schedule_timeout(long timeout)
188 {
189 long __retval;
190 freezer_do_not_count();
191 __retval = schedule_timeout(timeout);
192 freezer_count();
193 return __retval;
194 }
195
196 /*
197 * Like schedule_timeout_interruptible(), but should not block the freezer. Do not
198 * call this with locks held.
199 */
freezable_schedule_timeout_interruptible(long timeout)200 static inline long freezable_schedule_timeout_interruptible(long timeout)
201 {
202 long __retval;
203 freezer_do_not_count();
204 __retval = schedule_timeout_interruptible(timeout);
205 freezer_count();
206 return __retval;
207 }
208
209 /* Like schedule_timeout_killable(), but should not block the freezer. */
freezable_schedule_timeout_killable(long timeout)210 static inline long freezable_schedule_timeout_killable(long timeout)
211 {
212 long __retval;
213 freezer_do_not_count();
214 __retval = schedule_timeout_killable(timeout);
215 freezer_count();
216 return __retval;
217 }
218
219 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
freezable_schedule_timeout_killable_unsafe(long timeout)220 static inline long freezable_schedule_timeout_killable_unsafe(long timeout)
221 {
222 long __retval;
223 freezer_do_not_count();
224 __retval = schedule_timeout_killable(timeout);
225 freezer_count_unsafe();
226 return __retval;
227 }
228
229 /*
230 * Like schedule_hrtimeout_range(), but should not block the freezer. Do not
231 * call this with locks held.
232 */
freezable_schedule_hrtimeout_range(ktime_t * expires,unsigned long delta,const enum hrtimer_mode mode)233 static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
234 unsigned long delta, const enum hrtimer_mode mode)
235 {
236 int __retval;
237 freezer_do_not_count();
238 __retval = schedule_hrtimeout_range(expires, delta, mode);
239 freezer_count();
240 return __retval;
241 }
242
243 /*
244 * Freezer-friendly wrappers around wait_event_interruptible(),
245 * wait_event_killable() and wait_event_interruptible_timeout(), originally
246 * defined in <linux/wait.h>
247 */
248
249 #define wait_event_freezekillable(wq, condition) \
250 ({ \
251 int __retval; \
252 freezer_do_not_count(); \
253 __retval = wait_event_killable(wq, (condition)); \
254 freezer_count(); \
255 __retval; \
256 })
257
258 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
259 #define wait_event_freezekillable_unsafe(wq, condition) \
260 ({ \
261 int __retval; \
262 freezer_do_not_count(); \
263 __retval = wait_event_killable(wq, (condition)); \
264 freezer_count_unsafe(); \
265 __retval; \
266 })
267
268 #define wait_event_freezable(wq, condition) \
269 ({ \
270 int __retval; \
271 freezer_do_not_count(); \
272 __retval = wait_event_interruptible(wq, (condition)); \
273 freezer_count(); \
274 __retval; \
275 })
276
277 #define wait_event_freezable_timeout(wq, condition, timeout) \
278 ({ \
279 long __retval = timeout; \
280 freezer_do_not_count(); \
281 __retval = wait_event_interruptible_timeout(wq, (condition), \
282 __retval); \
283 freezer_count(); \
284 __retval; \
285 })
286
287 #define wait_event_freezable_exclusive(wq, condition) \
288 ({ \
289 int __retval; \
290 freezer_do_not_count(); \
291 __retval = wait_event_interruptible_exclusive(wq, condition); \
292 freezer_count(); \
293 __retval; \
294 })
295
296
297 #else /* !CONFIG_FREEZER */
frozen(struct task_struct * p)298 static inline bool frozen(struct task_struct *p) { return false; }
freezing(struct task_struct * p)299 static inline bool freezing(struct task_struct *p) { return false; }
__thaw_task(struct task_struct * t)300 static inline void __thaw_task(struct task_struct *t) {}
301
__refrigerator(bool check_kthr_stop)302 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
freeze_processes(void)303 static inline int freeze_processes(void) { return -ENOSYS; }
freeze_kernel_threads(void)304 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
thaw_processes(void)305 static inline void thaw_processes(void) {}
thaw_kernel_threads(void)306 static inline void thaw_kernel_threads(void) {}
307
try_to_freeze_nowarn(void)308 static inline bool try_to_freeze_nowarn(void) { return false; }
try_to_freeze(void)309 static inline bool try_to_freeze(void) { return false; }
310
freezer_do_not_count(void)311 static inline void freezer_do_not_count(void) {}
freezer_count(void)312 static inline void freezer_count(void) {}
freezer_should_skip(struct task_struct * p)313 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
set_freezable(void)314 static inline void set_freezable(void) {}
315
316 #define freezable_schedule() schedule()
317
318 #define freezable_schedule_unsafe() schedule()
319
320 #define freezable_schedule_timeout(timeout) schedule_timeout(timeout)
321
322 #define freezable_schedule_timeout_interruptible(timeout) \
323 schedule_timeout_interruptible(timeout)
324
325 #define freezable_schedule_timeout_killable(timeout) \
326 schedule_timeout_killable(timeout)
327
328 #define freezable_schedule_timeout_killable_unsafe(timeout) \
329 schedule_timeout_killable(timeout)
330
331 #define freezable_schedule_hrtimeout_range(expires, delta, mode) \
332 schedule_hrtimeout_range(expires, delta, mode)
333
334 #define wait_event_freezable(wq, condition) \
335 wait_event_interruptible(wq, condition)
336
337 #define wait_event_freezable_timeout(wq, condition, timeout) \
338 wait_event_interruptible_timeout(wq, condition, timeout)
339
340 #define wait_event_freezable_exclusive(wq, condition) \
341 wait_event_interruptible_exclusive(wq, condition)
342
343 #define wait_event_freezekillable(wq, condition) \
344 wait_event_killable(wq, condition)
345
346 #define wait_event_freezekillable_unsafe(wq, condition) \
347 wait_event_killable(wq, condition)
348
349 #endif /* !CONFIG_FREEZER */
350
351 #endif /* FREEZER_H_INCLUDED */
352