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 * Check if a process has been frozen
18 static inline bool frozen(struct task_struct *p)
20 return p->flags & PF_FROZEN;
23 extern bool freezing_slow_path(struct task_struct *p);
26 * Check if there is a request to freeze a process
28 static inline bool freezing(struct task_struct *p)
30 if (likely(!atomic_read(&system_freezing_cnt)))
32 return freezing_slow_path(p);
35 /* Takes and releases task alloc lock using task_lock() */
36 extern void __thaw_task(struct task_struct *t);
38 extern bool __refrigerator(bool check_kthr_stop);
39 extern int freeze_processes(void);
40 extern int freeze_kernel_threads(void);
41 extern void thaw_processes(void);
43 static inline bool try_to_freeze(void)
46 if (likely(!freezing(current)))
48 return __refrigerator(false);
51 extern bool freeze_task(struct task_struct *p);
52 extern bool set_freezable(void);
54 #ifdef CONFIG_CGROUP_FREEZER
55 extern bool cgroup_freezing(struct task_struct *task);
56 #else /* !CONFIG_CGROUP_FREEZER */
57 static inline bool cgroup_freezing(struct task_struct *task)
61 #endif /* !CONFIG_CGROUP_FREEZER */
64 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
65 * calls wait_for_completion(&vfork) and reset right after it returns from this
66 * function. Next, the parent should call try_to_freeze() to freeze itself
67 * appropriately in case the child has exited before the freezing of tasks is
68 * complete. However, we don't want kernel threads to be frozen in unexpected
69 * places, so we allow them to block freeze_processes() instead or to set
70 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
71 * parents. Fortunately, in the ____call_usermodehelper() case the parent won't
72 * really block freeze_processes(), since ____call_usermodehelper() (the child)
73 * does a little before exec/exit and it can't be frozen before waking up the
78 * If the current task is a user space one, tell the freezer not to count it as
81 static inline void freezer_do_not_count(void)
84 current->flags |= PF_FREEZER_SKIP;
88 * If the current task is a user space one, tell the freezer to count it as
89 * freezable again and try to freeze it.
91 static inline void freezer_count(void)
94 current->flags &= ~PF_FREEZER_SKIP;
100 * Check if the task should be counted as freezable by the freezer
102 static inline int freezer_should_skip(struct task_struct *p)
104 return !!(p->flags & PF_FREEZER_SKIP);
108 * These macros are intended to be used whenever you want allow a task that's
109 * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
110 * that neither return any clear indication of whether a freeze event happened
111 * while in this function.
114 /* Like schedule(), but should not block the freezer. */
115 #define freezable_schedule() \
117 freezer_do_not_count(); \
122 /* Like schedule_timeout_killable(), but should not block the freezer. */
123 #define freezable_schedule_timeout_killable(timeout) \
125 freezer_do_not_count(); \
126 schedule_timeout_killable(timeout); \
131 * Freezer-friendly wrappers around wait_event_interruptible(),
132 * wait_event_killable() and wait_event_interruptible_timeout(), originally
133 * defined in <linux/wait.h>
136 #define wait_event_freezekillable(wq, condition) \
139 freezer_do_not_count(); \
140 __retval = wait_event_killable(wq, (condition)); \
145 #define wait_event_freezable(wq, condition) \
149 __retval = wait_event_interruptible(wq, \
150 (condition) || freezing(current)); \
151 if (__retval || (condition)) \
158 #define wait_event_freezable_timeout(wq, condition, timeout) \
160 long __retval = timeout; \
162 __retval = wait_event_interruptible_timeout(wq, \
163 (condition) || freezing(current), \
165 if (__retval <= 0 || (condition)) \
172 #else /* !CONFIG_FREEZER */
173 static inline bool frozen(struct task_struct *p) { return false; }
174 static inline bool freezing(struct task_struct *p) { return false; }
175 static inline void __thaw_task(struct task_struct *t) {}
177 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
178 static inline int freeze_processes(void) { return -ENOSYS; }
179 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
180 static inline void thaw_processes(void) {}
182 static inline bool try_to_freeze(void) { return false; }
184 static inline void freezer_do_not_count(void) {}
185 static inline void freezer_count(void) {}
186 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
187 static inline void set_freezable(void) {}
189 #define freezable_schedule() schedule()
191 #define freezable_schedule_timeout_killable(timeout) \
192 schedule_timeout_killable(timeout)
194 #define wait_event_freezable(wq, condition) \
195 wait_event_interruptible(wq, condition)
197 #define wait_event_freezable_timeout(wq, condition, timeout) \
198 wait_event_interruptible_timeout(wq, condition, timeout)
200 #define wait_event_freezekillable(wq, condition) \
201 wait_event_killable(wq, condition)
203 #endif /* !CONFIG_FREEZER */
205 #endif /* FREEZER_H_INCLUDED */