1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/export.h>
18#include <linux/slab.h>
19#include <linux/cgroup.h>
20#include <linux/fs.h>
21#include <linux/uaccess.h>
22#include <linux/freezer.h>
23#include <linux/seq_file.h>
24
25
26
27
28
29
30
31
32enum freezer_state_flags {
33 CGROUP_FREEZER_ONLINE = (1 << 0),
34 CGROUP_FREEZING_SELF = (1 << 1),
35 CGROUP_FREEZING_PARENT = (1 << 2),
36 CGROUP_FROZEN = (1 << 3),
37
38
39 CGROUP_FREEZING = CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT,
40};
41
42struct freezer {
43 struct cgroup_subsys_state css;
44 unsigned int state;
45 spinlock_t lock;
46};
47
48static inline struct freezer *css_freezer(struct cgroup_subsys_state *css)
49{
50 return css ? container_of(css, struct freezer, css) : NULL;
51}
52
53static inline struct freezer *task_freezer(struct task_struct *task)
54{
55 return css_freezer(task_css(task, freezer_subsys_id));
56}
57
58static struct freezer *parent_freezer(struct freezer *freezer)
59{
60 return css_freezer(css_parent(&freezer->css));
61}
62
63bool cgroup_freezing(struct task_struct *task)
64{
65 bool ret;
66
67 rcu_read_lock();
68 ret = task_freezer(task)->state & CGROUP_FREEZING;
69 rcu_read_unlock();
70
71 return ret;
72}
73
74
75
76
77
78static const char *freezer_state_strs(unsigned int state)
79{
80 if (state & CGROUP_FROZEN)
81 return "FROZEN";
82 if (state & CGROUP_FREEZING)
83 return "FREEZING";
84 return "THAWED";
85};
86
87struct cgroup_subsys freezer_subsys;
88
89static struct cgroup_subsys_state *
90freezer_css_alloc(struct cgroup_subsys_state *parent_css)
91{
92 struct freezer *freezer;
93
94 freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
95 if (!freezer)
96 return ERR_PTR(-ENOMEM);
97
98 spin_lock_init(&freezer->lock);
99 return &freezer->css;
100}
101
102
103
104
105
106
107
108
109
110static int freezer_css_online(struct cgroup_subsys_state *css)
111{
112 struct freezer *freezer = css_freezer(css);
113 struct freezer *parent = parent_freezer(freezer);
114
115
116
117
118
119
120 if (parent)
121 spin_lock_irq(&parent->lock);
122 spin_lock_nested(&freezer->lock, SINGLE_DEPTH_NESTING);
123
124 freezer->state |= CGROUP_FREEZER_ONLINE;
125
126 if (parent && (parent->state & CGROUP_FREEZING)) {
127 freezer->state |= CGROUP_FREEZING_PARENT | CGROUP_FROZEN;
128 atomic_inc(&system_freezing_cnt);
129 }
130
131 spin_unlock(&freezer->lock);
132 if (parent)
133 spin_unlock_irq(&parent->lock);
134
135 return 0;
136}
137
138
139
140
141
142
143
144
145static void freezer_css_offline(struct cgroup_subsys_state *css)
146{
147 struct freezer *freezer = css_freezer(css);
148
149 spin_lock_irq(&freezer->lock);
150
151 if (freezer->state & CGROUP_FREEZING)
152 atomic_dec(&system_freezing_cnt);
153
154 freezer->state = 0;
155
156 spin_unlock_irq(&freezer->lock);
157}
158
159static void freezer_css_free(struct cgroup_subsys_state *css)
160{
161 kfree(css_freezer(css));
162}
163
164
165
166
167
168
169
170
171
172
173static void freezer_attach(struct cgroup_subsys_state *new_css,
174 struct cgroup_taskset *tset)
175{
176 struct freezer *freezer = css_freezer(new_css);
177 struct task_struct *task;
178 bool clear_frozen = false;
179
180 spin_lock_irq(&freezer->lock);
181
182
183
184
185
186
187
188
189
190
191
192 cgroup_taskset_for_each(task, new_css, tset) {
193 if (!(freezer->state & CGROUP_FREEZING)) {
194 __thaw_task(task);
195 } else {
196 freeze_task(task);
197 freezer->state &= ~CGROUP_FROZEN;
198 clear_frozen = true;
199 }
200 }
201
202 spin_unlock_irq(&freezer->lock);
203
204
205
206
207
208
209
210
211 while (clear_frozen && (freezer = parent_freezer(freezer))) {
212 spin_lock_irq(&freezer->lock);
213 freezer->state &= ~CGROUP_FROZEN;
214 clear_frozen = freezer->state & CGROUP_FREEZING;
215 spin_unlock_irq(&freezer->lock);
216 }
217}
218
219static void freezer_fork(struct task_struct *task)
220{
221 struct freezer *freezer;
222
223 rcu_read_lock();
224 freezer = task_freezer(task);
225
226
227
228
229
230 if (!parent_freezer(freezer))
231 goto out;
232
233 spin_lock_irq(&freezer->lock);
234 if (freezer->state & CGROUP_FREEZING)
235 freeze_task(task);
236 spin_unlock_irq(&freezer->lock);
237out:
238 rcu_read_unlock();
239}
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257static void update_if_frozen(struct cgroup_subsys_state *css)
258{
259 struct freezer *freezer = css_freezer(css);
260 struct cgroup_subsys_state *pos;
261 struct css_task_iter it;
262 struct task_struct *task;
263
264 WARN_ON_ONCE(!rcu_read_lock_held());
265
266 spin_lock_irq(&freezer->lock);
267
268 if (!(freezer->state & CGROUP_FREEZING) ||
269 (freezer->state & CGROUP_FROZEN))
270 goto out_unlock;
271
272
273 css_for_each_child(pos, css) {
274 struct freezer *child = css_freezer(pos);
275
276 if ((child->state & CGROUP_FREEZER_ONLINE) &&
277 !(child->state & CGROUP_FROZEN))
278 goto out_unlock;
279 }
280
281
282 css_task_iter_start(css, &it);
283
284 while ((task = css_task_iter_next(&it))) {
285 if (freezing(task)) {
286
287
288
289
290
291
292 if (!frozen(task) && !freezer_should_skip(task))
293 goto out_iter_end;
294 }
295 }
296
297 freezer->state |= CGROUP_FROZEN;
298out_iter_end:
299 css_task_iter_end(&it);
300out_unlock:
301 spin_unlock_irq(&freezer->lock);
302}
303
304static int freezer_read(struct cgroup_subsys_state *css, struct cftype *cft,
305 struct seq_file *m)
306{
307 struct cgroup_subsys_state *pos;
308
309 rcu_read_lock();
310
311
312 css_for_each_descendant_post(pos, css)
313 update_if_frozen(pos);
314
315 rcu_read_unlock();
316
317 seq_puts(m, freezer_state_strs(css_freezer(css)->state));
318 seq_putc(m, '\n');
319 return 0;
320}
321
322static void freeze_cgroup(struct freezer *freezer)
323{
324 struct css_task_iter it;
325 struct task_struct *task;
326
327 css_task_iter_start(&freezer->css, &it);
328 while ((task = css_task_iter_next(&it)))
329 freeze_task(task);
330 css_task_iter_end(&it);
331}
332
333static void unfreeze_cgroup(struct freezer *freezer)
334{
335 struct css_task_iter it;
336 struct task_struct *task;
337
338 css_task_iter_start(&freezer->css, &it);
339 while ((task = css_task_iter_next(&it)))
340 __thaw_task(task);
341 css_task_iter_end(&it);
342}
343
344
345
346
347
348
349
350
351
352
353static void freezer_apply_state(struct freezer *freezer, bool freeze,
354 unsigned int state)
355{
356
357 lockdep_assert_held(&freezer->lock);
358
359 if (!(freezer->state & CGROUP_FREEZER_ONLINE))
360 return;
361
362 if (freeze) {
363 if (!(freezer->state & CGROUP_FREEZING))
364 atomic_inc(&system_freezing_cnt);
365 freezer->state |= state;
366 freeze_cgroup(freezer);
367 } else {
368 bool was_freezing = freezer->state & CGROUP_FREEZING;
369
370 freezer->state &= ~state;
371
372 if (!(freezer->state & CGROUP_FREEZING)) {
373 if (was_freezing)
374 atomic_dec(&system_freezing_cnt);
375 freezer->state &= ~CGROUP_FROZEN;
376 unfreeze_cgroup(freezer);
377 }
378 }
379}
380
381
382
383
384
385
386
387
388
389static void freezer_change_state(struct freezer *freezer, bool freeze)
390{
391 struct cgroup_subsys_state *pos;
392
393
394
395
396
397
398 rcu_read_lock();
399 css_for_each_descendant_pre(pos, &freezer->css) {
400 struct freezer *pos_f = css_freezer(pos);
401 struct freezer *parent = parent_freezer(pos_f);
402
403 spin_lock_irq(&pos_f->lock);
404
405 if (pos_f == freezer) {
406 freezer_apply_state(pos_f, freeze,
407 CGROUP_FREEZING_SELF);
408 } else {
409
410
411
412
413
414
415 freezer_apply_state(pos_f,
416 parent->state & CGROUP_FREEZING,
417 CGROUP_FREEZING_PARENT);
418 }
419
420 spin_unlock_irq(&pos_f->lock);
421 }
422 rcu_read_unlock();
423}
424
425static int freezer_write(struct cgroup_subsys_state *css, struct cftype *cft,
426 const char *buffer)
427{
428 bool freeze;
429
430 if (strcmp(buffer, freezer_state_strs(0)) == 0)
431 freeze = false;
432 else if (strcmp(buffer, freezer_state_strs(CGROUP_FROZEN)) == 0)
433 freeze = true;
434 else
435 return -EINVAL;
436
437 freezer_change_state(css_freezer(css), freeze);
438 return 0;
439}
440
441static u64 freezer_self_freezing_read(struct cgroup_subsys_state *css,
442 struct cftype *cft)
443{
444 struct freezer *freezer = css_freezer(css);
445
446 return (bool)(freezer->state & CGROUP_FREEZING_SELF);
447}
448
449static u64 freezer_parent_freezing_read(struct cgroup_subsys_state *css,
450 struct cftype *cft)
451{
452 struct freezer *freezer = css_freezer(css);
453
454 return (bool)(freezer->state & CGROUP_FREEZING_PARENT);
455}
456
457static struct cftype files[] = {
458 {
459 .name = "state",
460 .flags = CFTYPE_NOT_ON_ROOT,
461 .read_seq_string = freezer_read,
462 .write_string = freezer_write,
463 },
464 {
465 .name = "self_freezing",
466 .flags = CFTYPE_NOT_ON_ROOT,
467 .read_u64 = freezer_self_freezing_read,
468 },
469 {
470 .name = "parent_freezing",
471 .flags = CFTYPE_NOT_ON_ROOT,
472 .read_u64 = freezer_parent_freezing_read,
473 },
474 { }
475};
476
477struct cgroup_subsys freezer_subsys = {
478 .name = "freezer",
479 .css_alloc = freezer_css_alloc,
480 .css_online = freezer_css_online,
481 .css_offline = freezer_css_offline,
482 .css_free = freezer_css_free,
483 .subsys_id = freezer_subsys_id,
484 .attach = freezer_attach,
485 .fork = freezer_fork,
486 .base_cftypes = files,
487};
488