1 /* Freezer declarations */
3 #ifndef FREEZER_H_INCLUDED
4 #define FREEZER_H_INCLUDED
6 #include <linux/sched.h>
7 #include <linux/wait.h>
11 * Check if a process has been frozen
13 static inline int frozen(struct task_struct *p)
15 return p->flags & PF_FROZEN;
19 * Check if there is a request to freeze a process
21 static inline int freezing(struct task_struct *p)
23 return test_tsk_thread_flag(p, TIF_FREEZE);
27 * Request that a process be frozen
29 static inline void set_freeze_flag(struct task_struct *p)
31 set_tsk_thread_flag(p, TIF_FREEZE);
35 * Sometimes we may need to cancel the previous 'freeze' request
37 static inline void clear_freeze_flag(struct task_struct *p)
39 clear_tsk_thread_flag(p, TIF_FREEZE);
42 static inline bool should_send_signal(struct task_struct *p)
44 return !(p->flags & PF_FREEZER_NOSIG);
47 /* Takes and releases task alloc lock using task_lock() */
48 extern int thaw_process(struct task_struct *p);
50 extern void refrigerator(void);
51 extern int freeze_processes(void);
52 extern int freeze_kernel_threads(void);
53 extern void thaw_processes(void);
54 extern void thaw_kernel_threads(void);
56 static inline int try_to_freeze(void)
58 if (freezing(current)) {
65 extern bool freeze_task(struct task_struct *p, bool sig_only);
66 extern void cancel_freezing(struct task_struct *p);
68 #ifdef CONFIG_CGROUP_FREEZER
69 extern int cgroup_freezing_or_frozen(struct task_struct *task);
70 #else /* !CONFIG_CGROUP_FREEZER */
71 static inline int cgroup_freezing_or_frozen(struct task_struct *task)
75 #endif /* !CONFIG_CGROUP_FREEZER */
78 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
79 * calls wait_for_completion(&vfork) and reset right after it returns from this
80 * function. Next, the parent should call try_to_freeze() to freeze itself
81 * appropriately in case the child has exited before the freezing of tasks is
82 * complete. However, we don't want kernel threads to be frozen in unexpected
83 * places, so we allow them to block freeze_processes() instead or to set
84 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
85 * parents. Fortunately, in the ____call_usermodehelper() case the parent won't
86 * really block freeze_processes(), since ____call_usermodehelper() (the child)
87 * does a little before exec/exit and it can't be frozen before waking up the
92 * freezer_do_not_count - tell freezer to ignore %current if a user space task
94 * Tell freezers to ignore the current task when determining whether the
95 * target frozen state is reached. IOW, the current task will be
96 * considered frozen enough by freezers.
98 * The caller shouldn't do anything which isn't allowed for a frozen task
99 * until freezer_cont() is called. Usually, freezer[_do_not]_count() pair
100 * wrap a scheduling operation and nothing much else.
102 static inline void freezer_do_not_count(void)
105 current->flags |= PF_FREEZER_SKIP;
109 * freezer_count - tell freezer to stop ignoring %current if a user space task
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)
118 current->flags &= ~PF_FREEZER_SKIP;
120 * If freezing is in progress, the following paired with smp_mb()
121 * in freezer_should_skip() ensures that either we see %true
122 * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
130 * freezer_should_skip - whether to skip a task when determining frozen
132 * @p: task in quesion
134 * This function is used by freezers after establishing %true freezing() to
135 * test whether a task should be skipped when determining the target frozen
136 * state is reached. IOW, if this function returns %true, @p is considered
139 static inline bool freezer_should_skip(struct task_struct *p)
142 * The following smp_mb() paired with the one in freezer_count()
143 * ensures that either freezer_count() sees %true freezing() or we
144 * see cleared %PF_FREEZER_SKIP and return %false. This makes it
145 * impossible for a task to slip frozen state testing after
146 * clearing %PF_FREEZER_SKIP.
149 return p->flags & PF_FREEZER_SKIP;
153 * Tell the freezer that the current task should be frozen by it
155 static inline void set_freezable(void)
157 current->flags &= ~PF_NOFREEZE;
161 * Tell the freezer that the current task should be frozen by it and that it
162 * should send a fake signal to the task to freeze it.
164 static inline void set_freezable_with_signal(void)
166 current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
170 * Freezer-friendly wrappers around wait_event_interruptible(),
171 * wait_event_killable() and wait_event_interruptible_timeout(), originally
172 * defined in <linux/wait.h>
175 #define wait_event_freezekillable(wq, condition) \
178 freezer_do_not_count(); \
179 __retval = wait_event_killable(wq, (condition)); \
184 #define wait_event_freezable(wq, condition) \
188 __retval = wait_event_interruptible(wq, \
189 (condition) || freezing(current)); \
190 if (__retval && !freezing(current)) \
192 else if (!(condition)) \
193 __retval = -ERESTARTSYS; \
194 } while (try_to_freeze()); \
199 #define wait_event_freezable_timeout(wq, condition, timeout) \
201 long __retval = timeout; \
203 __retval = wait_event_interruptible_timeout(wq, \
204 (condition) || freezing(current), \
206 } while (try_to_freeze()); \
209 #else /* !CONFIG_FREEZER */
210 static inline int frozen(struct task_struct *p) { return 0; }
211 static inline int freezing(struct task_struct *p) { return 0; }
212 static inline void set_freeze_flag(struct task_struct *p) {}
213 static inline void clear_freeze_flag(struct task_struct *p) {}
214 static inline int thaw_process(struct task_struct *p) { return 1; }
216 static inline void refrigerator(void) {}
217 static inline int freeze_processes(void) { return -ENOSYS; }
218 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
219 static inline void thaw_processes(void) {}
220 static inline void thaw_kernel_threads(void) {}
222 static inline int try_to_freeze(void) { return 0; }
224 static inline void freezer_do_not_count(void) {}
225 static inline void freezer_count(void) {}
226 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
227 static inline void set_freezable(void) {}
228 static inline void set_freezable_with_signal(void) {}
230 #define wait_event_freezable(wq, condition) \
231 wait_event_interruptible(wq, condition)
233 #define wait_event_freezable_timeout(wq, condition, timeout) \
234 wait_event_interruptible_timeout(wq, condition, timeout)
236 #define wait_event_freezekillable(wq, condition) \
237 wait_event_killable(wq, condition)
239 #endif /* !CONFIG_FREEZER */
241 #endif /* FREEZER_H_INCLUDED */