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
9 #ifdef CONFIG_FREEZER
10 /*
11 * Check if a process has been frozen
12 */
frozen(struct task_struct * p)13 static inline int frozen(struct task_struct *p)
14 {
15 return p->flags & PF_FROZEN;
16 }
17
18 /*
19 * Check if there is a request to freeze a process
20 */
freezing(struct task_struct * p)21 static inline int freezing(struct task_struct *p)
22 {
23 return test_tsk_thread_flag(p, TIF_FREEZE);
24 }
25
26 /*
27 * Request that a process be frozen
28 */
set_freeze_flag(struct task_struct * p)29 static inline void set_freeze_flag(struct task_struct *p)
30 {
31 set_tsk_thread_flag(p, TIF_FREEZE);
32 }
33
34 /*
35 * Sometimes we may need to cancel the previous 'freeze' request
36 */
clear_freeze_flag(struct task_struct * p)37 static inline void clear_freeze_flag(struct task_struct *p)
38 {
39 clear_tsk_thread_flag(p, TIF_FREEZE);
40 }
41
should_send_signal(struct task_struct * p)42 static inline bool should_send_signal(struct task_struct *p)
43 {
44 return !(p->flags & PF_FREEZER_NOSIG);
45 }
46
47 /* Takes and releases task alloc lock using task_lock() */
48 extern int thaw_process(struct task_struct *p);
49
50 extern void refrigerator(void);
51 extern int freeze_processes(void);
52 extern void thaw_processes(void);
53
try_to_freeze(void)54 static inline int try_to_freeze(void)
55 {
56 if (freezing(current)) {
57 refrigerator();
58 return 1;
59 } else
60 return 0;
61 }
62
63 extern bool freeze_task(struct task_struct *p, bool sig_only);
64 extern void cancel_freezing(struct task_struct *p);
65
66 #ifdef CONFIG_CGROUP_FREEZER
67 extern int cgroup_freezing_or_frozen(struct task_struct *task);
68 #else /* !CONFIG_CGROUP_FREEZER */
cgroup_freezing_or_frozen(struct task_struct * task)69 static inline int cgroup_freezing_or_frozen(struct task_struct *task)
70 {
71 return 0;
72 }
73 #endif /* !CONFIG_CGROUP_FREEZER */
74
75 /*
76 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it
77 * calls wait_for_completion(&vfork) and reset right after it returns from this
78 * function. Next, the parent should call try_to_freeze() to freeze itself
79 * appropriately in case the child has exited before the freezing of tasks is
80 * complete. However, we don't want kernel threads to be frozen in unexpected
81 * places, so we allow them to block freeze_processes() instead or to set
82 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork
83 * parents. Fortunately, in the ____call_usermodehelper() case the parent won't
84 * really block freeze_processes(), since ____call_usermodehelper() (the child)
85 * does a little before exec/exit and it can't be frozen before waking up the
86 * parent.
87 */
88
89 /*
90 * If the current task is a user space one, tell the freezer not to count it as
91 * freezable.
92 */
freezer_do_not_count(void)93 static inline void freezer_do_not_count(void)
94 {
95 if (current->mm)
96 current->flags |= PF_FREEZER_SKIP;
97 }
98
99 /*
100 * If the current task is a user space one, tell the freezer to count it as
101 * freezable again and try to freeze it.
102 */
freezer_count(void)103 static inline void freezer_count(void)
104 {
105 if (current->mm) {
106 current->flags &= ~PF_FREEZER_SKIP;
107 try_to_freeze();
108 }
109 }
110
111 /*
112 * Check if the task should be counted as freezable by the freezer
113 */
freezer_should_skip(struct task_struct * p)114 static inline int freezer_should_skip(struct task_struct *p)
115 {
116 return !!(p->flags & PF_FREEZER_SKIP);
117 }
118
119 /*
120 * Tell the freezer that the current task should be frozen by it
121 */
set_freezable(void)122 static inline void set_freezable(void)
123 {
124 current->flags &= ~PF_NOFREEZE;
125 }
126
127 /*
128 * Tell the freezer that the current task should be frozen by it and that it
129 * should send a fake signal to the task to freeze it.
130 */
set_freezable_with_signal(void)131 static inline void set_freezable_with_signal(void)
132 {
133 current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG);
134 }
135
136 /*
137 * Freezer-friendly wrappers around wait_event_interruptible() and
138 * wait_event_interruptible_timeout(), originally defined in <linux/wait.h>
139 */
140
141 #define wait_event_freezable(wq, condition) \
142 ({ \
143 int __retval; \
144 do { \
145 __retval = wait_event_interruptible(wq, \
146 (condition) || freezing(current)); \
147 if (__retval && !freezing(current)) \
148 break; \
149 else if (!(condition)) \
150 __retval = -ERESTARTSYS; \
151 } while (try_to_freeze()); \
152 __retval; \
153 })
154
155
156 #define wait_event_freezable_timeout(wq, condition, timeout) \
157 ({ \
158 long __retval = timeout; \
159 do { \
160 __retval = wait_event_interruptible_timeout(wq, \
161 (condition) || freezing(current), \
162 __retval); \
163 } while (try_to_freeze()); \
164 __retval; \
165 })
166 #else /* !CONFIG_FREEZER */
frozen(struct task_struct * p)167 static inline int frozen(struct task_struct *p) { return 0; }
freezing(struct task_struct * p)168 static inline int freezing(struct task_struct *p) { return 0; }
set_freeze_flag(struct task_struct * p)169 static inline void set_freeze_flag(struct task_struct *p) {}
clear_freeze_flag(struct task_struct * p)170 static inline void clear_freeze_flag(struct task_struct *p) {}
thaw_process(struct task_struct * p)171 static inline int thaw_process(struct task_struct *p) { return 1; }
172
refrigerator(void)173 static inline void refrigerator(void) {}
freeze_processes(void)174 static inline int freeze_processes(void) { BUG(); return 0; }
thaw_processes(void)175 static inline void thaw_processes(void) {}
176
try_to_freeze(void)177 static inline int try_to_freeze(void) { return 0; }
178
freezer_do_not_count(void)179 static inline void freezer_do_not_count(void) {}
freezer_count(void)180 static inline void freezer_count(void) {}
freezer_should_skip(struct task_struct * p)181 static inline int freezer_should_skip(struct task_struct *p) { return 0; }
set_freezable(void)182 static inline void set_freezable(void) {}
set_freezable_with_signal(void)183 static inline void set_freezable_with_signal(void) {}
184
185 #define wait_event_freezable(wq, condition) \
186 wait_event_interruptible(wq, condition)
187
188 #define wait_event_freezable_timeout(wq, condition, timeout) \
189 wait_event_interruptible_timeout(wq, condition, timeout)
190
191 #endif /* !CONFIG_FREEZER */
192
193 #endif /* FREEZER_H_INCLUDED */
194