|
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 */ |
|
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 */ |
|
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 */ |
|
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 */ |
|
37 static inline void clear_freeze_flag(struct task_struct *p) |
|
38 { |
|
39 clear_tsk_thread_flag(p, TIF_FREEZE); |
|
40 } |
|
41 |
|
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 |
|
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_frozen(struct task_struct *task); |
|
68 #else /* !CONFIG_CGROUP_FREEZER */ |
|
69 static inline int cgroup_frozen(struct task_struct *task) { return 0; } |
|
70 #endif /* !CONFIG_CGROUP_FREEZER */ |
|
71 |
|
72 /* |
|
73 * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it |
|
74 * calls wait_for_completion(&vfork) and reset right after it returns from this |
|
75 * function. Next, the parent should call try_to_freeze() to freeze itself |
|
76 * appropriately in case the child has exited before the freezing of tasks is |
|
77 * complete. However, we don't want kernel threads to be frozen in unexpected |
|
78 * places, so we allow them to block freeze_processes() instead or to set |
|
79 * PF_NOFREEZE if needed and PF_FREEZER_SKIP is only set for userland vfork |
|
80 * parents. Fortunately, in the ____call_usermodehelper() case the parent won't |
|
81 * really block freeze_processes(), since ____call_usermodehelper() (the child) |
|
82 * does a little before exec/exit and it can't be frozen before waking up the |
|
83 * parent. |
|
84 */ |
|
85 |
|
86 /* |
|
87 * If the current task is a user space one, tell the freezer not to count it as |
|
88 * freezable. |
|
89 */ |
|
90 static inline void freezer_do_not_count(void) |
|
91 { |
|
92 if (current->mm) |
|
93 current->flags |= PF_FREEZER_SKIP; |
|
94 } |
|
95 |
|
96 /* |
|
97 * If the current task is a user space one, tell the freezer to count it as |
|
98 * freezable again and try to freeze it. |
|
99 */ |
|
100 static inline void freezer_count(void) |
|
101 { |
|
102 if (current->mm) { |
|
103 current->flags &= ~PF_FREEZER_SKIP; |
|
104 try_to_freeze(); |
|
105 } |
|
106 } |
|
107 |
|
108 /* |
|
109 * Check if the task should be counted as freezeable by the freezer |
|
110 */ |
|
111 static inline int freezer_should_skip(struct task_struct *p) |
|
112 { |
|
113 return !!(p->flags & PF_FREEZER_SKIP); |
|
114 } |
|
115 |
|
116 /* |
|
117 * Tell the freezer that the current task should be frozen by it |
|
118 */ |
|
119 static inline void set_freezable(void) |
|
120 { |
|
121 current->flags &= ~PF_NOFREEZE; |
|
122 } |
|
123 |
|
124 /* |
|
125 * Tell the freezer that the current task should be frozen by it and that it |
|
126 * should send a fake signal to the task to freeze it. |
|
127 */ |
|
128 static inline void set_freezable_with_signal(void) |
|
129 { |
|
130 current->flags &= ~(PF_NOFREEZE | PF_FREEZER_NOSIG); |
|
131 } |
|
132 |
|
133 /* |
|
134 * Freezer-friendly wrappers around wait_event_interruptible() and |
|
135 * wait_event_interruptible_timeout(), originally defined in <linux/wait.h> |
|
136 */ |
|
137 |
|
138 #define wait_event_freezable(wq, condition) \ |
|
139 ({ \ |
|
140 int __retval; \ |
|
141 do { \ |
|
142 __retval = wait_event_interruptible(wq, \ |
|
143 (condition) || freezing(current)); \ |
|
144 if (__retval && !freezing(current)) \ |
|
145 break; \ |
|
146 else if (!(condition)) \ |
|
147 __retval = -ERESTARTSYS; \ |
|
148 } while (try_to_freeze()); \ |
|
149 __retval; \ |
|
150 }) |
|
151 |
|
152 |
|
153 #define wait_event_freezable_timeout(wq, condition, timeout) \ |
|
154 ({ \ |
|
155 long __retval = timeout; \ |
|
156 do { \ |
|
157 __retval = wait_event_interruptible_timeout(wq, \ |
|
158 (condition) || freezing(current), \ |
|
159 __retval); \ |
|
160 } while (try_to_freeze()); \ |
|
161 __retval; \ |
|
162 }) |
|
163 #else /* !CONFIG_FREEZER */ |
|
164 static inline int frozen(struct task_struct *p) { return 0; } |
|
165 static inline int freezing(struct task_struct *p) { return 0; } |
|
166 static inline void set_freeze_flag(struct task_struct *p) {} |
|
167 static inline void clear_freeze_flag(struct task_struct *p) {} |
|
168 static inline int thaw_process(struct task_struct *p) { return 1; } |
|
169 |
|
170 static inline void refrigerator(void) {} |
|
171 static inline int freeze_processes(void) { BUG(); return 0; } |
|
172 static inline void thaw_processes(void) {} |
|
173 |
|
174 static inline int try_to_freeze(void) { return 0; } |
|
175 |
|
176 static inline void freezer_do_not_count(void) {} |
|
177 static inline void freezer_count(void) {} |
|
178 static inline int freezer_should_skip(struct task_struct *p) { return 0; } |
|
179 static inline void set_freezable(void) {} |
|
180 static inline void set_freezable_with_signal(void) {} |
|
181 |
|
182 #define wait_event_freezable(wq, condition) \ |
|
183 wait_event_interruptible(wq, condition) |
|
184 |
|
185 #define wait_event_freezable_timeout(wq, condition, timeout) \ |
|
186 wait_event_interruptible_timeout(wq, condition, timeout) |
|
187 |
|
188 #endif /* !CONFIG_FREEZER */ |
|
189 |
|
190 #endif /* FREEZER_H_INCLUDED */ |