1 /* Freezer declarations */
2
3 #ifndef FREEZER_H_INCLUDED
4 #define FREEZER_H_INCLUDED
5
6 #include <linux/sched.h>
7 #include <linux/wait.h>
8 #include <linux/atomic.h>
9
10 #ifdef CONFIG_FREEZER
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 */
14
15 /*
16 * Check if a process has been frozen
17 */
frozen(struct task_struct * p)18 static inline bool frozen(struct task_struct *p)
19 {
20 return p->flags & PF_FROZEN;
21 }
22
23 extern bool freezing_slow_path(struct task_struct *p);
24
25 /*
26 * Check if there is a request to freeze a process
27 */
freezing(struct task_struct * p)28 static inline bool freezing(struct task_struct *p)
29 {
30 if (likely(!atomic_read(&system_freezing_cnt)))
31 return false;
32 return freezing_slow_path(p);
33 }
34
35 /* Takes and releases task alloc lock using task_lock() */
36 extern void __thaw_task(struct task_struct *t);
37
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);
42 extern void thaw_kernel_threads(void);
43
try_to_freeze(void)44 static inline bool try_to_freeze(void)
45 {
46 might_sleep();
47 if (likely(!freezing(current)))
48 return false;
49 return __refrigerator(false);
50 }
51
52 extern bool freeze_task(struct task_struct *p);
53 extern bool set_freezable(void);
54
55 #ifdef CONFIG_CGROUP_FREEZER
56 extern bool cgroup_freezing(struct task_struct *task);
57 #else /* !CONFIG_CGROUP_FREEZER */
cgroup_freezing(struct task_struct * task)58 static inline bool cgroup_freezing(struct task_struct *task)
59 {
60 return false;
61 }
62 #endif /* !CONFIG_CGROUP_FREEZER */
63
64 /*
65 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
66 * calls wait_for_completion(&vfork) and reset right after it returns from this
67 * function. Next, the parent should call try_to_freeze() to freeze itself
68 * appropriately in case the child has exited before the freezing of tasks is
69 * complete. However, we don't want kernel threads to be frozen in unexpected
70 * places, so we allow them to block freeze_processes() instead or to set
71 * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the
72 * parent won't really block freeze_processes(), since ____call_usermodehelper()
73 * (the child) does a little before exec/exit and it can't be frozen before
74 * waking up the parent.
75 */
76
77
78 /* Tell the freezer not to count the current task as freezable. */
freezer_do_not_count(void)79 static inline void freezer_do_not_count(void)
80 {
81 current->flags |= PF_FREEZER_SKIP;
82 }
83
84 /*
85 * Tell the freezer to count the current task as freezable again and try to
86 * freeze it.
87 */
freezer_count(void)88 static inline void freezer_count(void)
89 {
90 current->flags &= ~PF_FREEZER_SKIP;
91 try_to_freeze();
92 }
93
94 /*
95 * Check if the task should be counted as freezable by the freezer
96 */
freezer_should_skip(struct task_struct * p)97 static inline int freezer_should_skip(struct task_struct *p)
98 {
99 return !!(p->flags & PF_FREEZER_SKIP);
100 }
101
102 /*
103 * These macros are intended to be used whenever you want allow a task that's
104 * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
105 * that neither return any clear indication of whether a freeze event happened
106 * while in this function.
107 */
108
109 /* Like schedule(), but should not block the freezer. */
110 #define freezable_schedule() \
111 ({ \
112 freezer_do_not_count(); \
113 schedule(); \
114 freezer_count(); \
115 })
116
117 /* Like schedule_timeout_killable(), but should not block the freezer. */
118 #define freezable_schedule_timeout_killable(timeout) \
119 ({ \
120 long __retval; \
121 freezer_do_not_count(); \
122 __retval = schedule_timeout_killable(timeout); \
123 freezer_count(); \
124 __retval; \
125 })
126
127 /*
128 * Freezer-friendly wrappers around wait_event_interruptible(),
129 * wait_event_killable() and wait_event_interruptible_timeout(), originally
130 * defined in <linux/wait.h>
131 */
132
133 #define wait_event_freezekillable(wq, condition) \
134 ({ \
135 int __retval; \
136 freezer_do_not_count(); \
137 __retval = wait_event_killable(wq, (condition)); \
138 freezer_count(); \
139 __retval; \
140 })
141
142 #define wait_event_freezable(wq, condition) \
143 ({ \
144 int __retval; \
145 for (;;) { \
146 __retval = wait_event_interruptible(wq, \
147 (condition) || freezing(current)); \
148 if (__retval || (condition)) \
149 break; \
150 try_to_freeze(); \
151 } \
152 __retval; \
153 })
154
155 #define wait_event_freezable_timeout(wq, condition, timeout) \
156 ({ \
157 long __retval = timeout; \
158 for (;;) { \
159 __retval = wait_event_interruptible_timeout(wq, \
160 (condition) || freezing(current), \
161 __retval); \
162 if (__retval <= 0 || (condition)) \
163 break; \
164 try_to_freeze(); \
165 } \
166 __retval; \
167 })
168
169 #else /* !CONFIG_FREEZER */
frozen(struct task_struct * p)170 static inline bool frozen(struct task_struct *p) { return false; }
freezing(struct task_struct * p)171 static inline bool freezing(struct task_struct *p) { return false; }
__thaw_task(struct task_struct * t)172 static inline void __thaw_task(struct task_struct *t) {}
173
__refrigerator(bool check_kthr_stop)174 static inline bool __refrigerator(bool check_kthr_stop) { return false; }
freeze_processes(void)175 static inline int freeze_processes(void) { return -ENOSYS; }
freeze_kernel_threads(void)176 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
thaw_processes(void)177 static inline void thaw_processes(void) {}
thaw_kernel_threads(void)178 static inline void thaw_kernel_threads(void) {}
179
try_to_freeze(void)180 static inline bool try_to_freeze(void) { return false; }
181
freezer_do_not_count(void)182 static inline void freezer_do_not_count(void) {}
freezer_count(void)183 static inline void freezer_count(void) {}
freezer_should_skip(struct task_struct * p)184 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
set_freezable(void)185 static inline void set_freezable(void) {}
186
187 #define freezable_schedule() schedule()
188
189 #define freezable_schedule_timeout_killable(timeout) \
190 schedule_timeout_killable(timeout)
191
192 #define wait_event_freezable(wq, condition) \
193 wait_event_interruptible(wq, condition)
194
195 #define wait_event_freezable_timeout(wq, condition, timeout) \
196 wait_event_interruptible_timeout(wq, condition, timeout)
197
198 #define wait_event_freezekillable(wq, condition) \
199 wait_event_killable(wq, condition)
200
201 #endif /* !CONFIG_FREEZER */
202
203 #endif /* FREEZER_H_INCLUDED */
204