Blame view
kernel/cgroup_freezer.c
12.4 KB
dc52ddc0e
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/* * cgroup_freezer.c - control group freezer subsystem * * Copyright IBM Corporation, 2007 * * Author : Cedric Le Goater <clg@fr.ibm.com> * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2.1 of the GNU Lesser General Public License * as published by the Free Software Foundation. * * This program is distributed in the hope that it would be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ |
9984de1a5
|
16 |
#include <linux/export.h> |
5a0e3ad6a
|
17 |
#include <linux/slab.h> |
dc52ddc0e
|
18 19 20 21 22 |
#include <linux/cgroup.h> #include <linux/fs.h> #include <linux/uaccess.h> #include <linux/freezer.h> #include <linux/seq_file.h> |
e5ced8ebb
|
23 |
#include <linux/mutex.h> |
dc52ddc0e
|
24 |
|
ef9fe980c
|
25 26 27 28 29 30 31 |
/* * A cgroup is freezing if any FREEZING flags are set. FREEZING_SELF is * set if "FROZEN" is written to freezer.state cgroupfs file, and cleared * for "THAWED". FREEZING_PARENT is set if the parent freezer is FREEZING * for whatever reason. IOW, a cgroup has FREEZING_PARENT set if one of * its ancestors has FREEZING_SELF set. */ |
d6a2fe134
|
32 |
enum freezer_state_flags { |
5300a9b34
|
33 |
CGROUP_FREEZER_ONLINE = (1 << 0), /* freezer is fully online */ |
a22521806
|
34 35 |
CGROUP_FREEZING_SELF = (1 << 1), /* this freezer is freezing */ CGROUP_FREEZING_PARENT = (1 << 2), /* the parent freezer is freezing */ |
d6a2fe134
|
36 |
CGROUP_FROZEN = (1 << 3), /* this and its descendants frozen */ |
a22521806
|
37 38 39 |
/* mask for all FREEZING flags */ CGROUP_FREEZING = CGROUP_FREEZING_SELF | CGROUP_FREEZING_PARENT, |
dc52ddc0e
|
40 41 42 |
}; struct freezer { |
bcd66c894
|
43 |
struct cgroup_subsys_state css; |
d6a2fe134
|
44 |
unsigned int state; |
dc52ddc0e
|
45 |
}; |
e5ced8ebb
|
46 |
static DEFINE_MUTEX(freezer_mutex); |
a7c6d554a
|
47 48 49 50 |
static inline struct freezer *css_freezer(struct cgroup_subsys_state *css) { return css ? container_of(css, struct freezer, css) : NULL; } |
dc52ddc0e
|
51 52 |
static inline struct freezer *task_freezer(struct task_struct *task) { |
073219e99
|
53 |
return css_freezer(task_css(task, freezer_cgrp_id)); |
dc52ddc0e
|
54 |
} |
ef9fe980c
|
55 56 |
static struct freezer *parent_freezer(struct freezer *freezer) { |
5c9d535b8
|
57 |
return css_freezer(freezer->css.parent); |
ef9fe980c
|
58 |
} |
22b4e111f
|
59 |
bool cgroup_freezing(struct task_struct *task) |
dc52ddc0e
|
60 |
{ |
22b4e111f
|
61 |
bool ret; |
dc52ddc0e
|
62 |
|
22b4e111f
|
63 |
rcu_read_lock(); |
d6a2fe134
|
64 |
ret = task_freezer(task)->state & CGROUP_FREEZING; |
22b4e111f
|
65 66 67 |
rcu_read_unlock(); return ret; |
dc52ddc0e
|
68 |
} |
d6a2fe134
|
69 70 71 72 73 74 75 |
static const char *freezer_state_strs(unsigned int state) { if (state & CGROUP_FROZEN) return "FROZEN"; if (state & CGROUP_FREEZING) return "FREEZING"; return "THAWED"; |
dc52ddc0e
|
76 |
}; |
eb95419b0
|
77 78 |
static struct cgroup_subsys_state * freezer_css_alloc(struct cgroup_subsys_state *parent_css) |
dc52ddc0e
|
79 80 81 82 83 84 |
{ struct freezer *freezer; freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL); if (!freezer) return ERR_PTR(-ENOMEM); |
dc52ddc0e
|
85 86 |
return &freezer->css; } |
5300a9b34
|
87 |
/** |
eb95419b0
|
88 89 |
* freezer_css_online - commit creation of a freezer css * @css: css being created |
5300a9b34
|
90 |
* |
eb95419b0
|
91 |
* We're committing to creation of @css. Mark it online and inherit |
ef9fe980c
|
92 93 |
* parent's freezing state while holding both parent's and our * freezer->lock. |
5300a9b34
|
94 |
*/ |
eb95419b0
|
95 |
static int freezer_css_online(struct cgroup_subsys_state *css) |
dc52ddc0e
|
96 |
{ |
eb95419b0
|
97 |
struct freezer *freezer = css_freezer(css); |
ef9fe980c
|
98 |
struct freezer *parent = parent_freezer(freezer); |
e5ced8ebb
|
99 |
mutex_lock(&freezer_mutex); |
a3201227f
|
100 |
|
5300a9b34
|
101 |
freezer->state |= CGROUP_FREEZER_ONLINE; |
ef9fe980c
|
102 103 104 105 106 |
if (parent && (parent->state & CGROUP_FREEZING)) { freezer->state |= CGROUP_FREEZING_PARENT | CGROUP_FROZEN; atomic_inc(&system_freezing_cnt); } |
e5ced8ebb
|
107 |
mutex_unlock(&freezer_mutex); |
b1929db42
|
108 |
return 0; |
5300a9b34
|
109 110 111 |
} /** |
eb95419b0
|
112 113 |
* freezer_css_offline - initiate destruction of a freezer css * @css: css being destroyed |
5300a9b34
|
114 |
* |
eb95419b0
|
115 116 |
* @css is going away. Mark it dead and decrement system_freezing_count if * it was holding one. |
5300a9b34
|
117 |
*/ |
eb95419b0
|
118 |
static void freezer_css_offline(struct cgroup_subsys_state *css) |
5300a9b34
|
119 |
{ |
eb95419b0
|
120 |
struct freezer *freezer = css_freezer(css); |
5300a9b34
|
121 |
|
e5ced8ebb
|
122 |
mutex_lock(&freezer_mutex); |
5300a9b34
|
123 |
|
d6a2fe134
|
124 |
if (freezer->state & CGROUP_FREEZING) |
a3201227f
|
125 |
atomic_dec(&system_freezing_cnt); |
5300a9b34
|
126 127 |
freezer->state = 0; |
e5ced8ebb
|
128 |
mutex_unlock(&freezer_mutex); |
5300a9b34
|
129 |
} |
eb95419b0
|
130 |
static void freezer_css_free(struct cgroup_subsys_state *css) |
5300a9b34
|
131 |
{ |
eb95419b0
|
132 |
kfree(css_freezer(css)); |
dc52ddc0e
|
133 |
} |
957a4eeaf
|
134 |
/* |
ead5c4737
|
135 136 137 138 139 140 141 |
* Tasks can be migrated into a different freezer anytime regardless of its * current state. freezer_attach() is responsible for making new tasks * conform to the current state. * * Freezer state changes and task migration are synchronized via * @freezer->lock. freezer_attach() makes the new tasks conform to the * current state and all following state changes can see the new tasks. |
957a4eeaf
|
142 |
*/ |
1f7dd3e5a
|
143 |
static void freezer_attach(struct cgroup_taskset *tset) |
dc52ddc0e
|
144 |
{ |
bb9d97b6d
|
145 |
struct task_struct *task; |
1f7dd3e5a
|
146 |
struct cgroup_subsys_state *new_css; |
957a4eeaf
|
147 |
|
e5ced8ebb
|
148 |
mutex_lock(&freezer_mutex); |
8755ade68
|
149 |
|
80a6a2cf3
|
150 |
/* |
eb95419b0
|
151 |
* Make the new tasks conform to the current state of @new_css. |
8755ade68
|
152 153 154 155 |
* For simplicity, when migrating any task to a FROZEN cgroup, we * revert it to FREEZING and let update_if_frozen() determine the * correct state later. * |
eb95419b0
|
156 |
* Tasks in @tset are on @new_css but may not conform to its |
8755ade68
|
157 158 |
* current state before executing the following - !frozen tasks may * be visible in a FROZEN cgroup and frozen tasks in a THAWED one. |
80a6a2cf3
|
159 |
*/ |
1f7dd3e5a
|
160 |
cgroup_taskset_for_each(task, new_css, tset) { |
599c963a0
|
161 |
struct freezer *freezer = css_freezer(new_css); |
d6a2fe134
|
162 |
if (!(freezer->state & CGROUP_FREEZING)) { |
8755ade68
|
163 164 165 |
__thaw_task(task); } else { freeze_task(task); |
599c963a0
|
166 167 168 169 170 |
/* clear FROZEN and propagate upwards */ while (freezer && (freezer->state & CGROUP_FROZEN)) { freezer->state &= ~CGROUP_FROZEN; freezer = parent_freezer(freezer); } |
8755ade68
|
171 172 |
} } |
dc52ddc0e
|
173 |
|
e5ced8ebb
|
174 |
mutex_unlock(&freezer_mutex); |
f780bdb7c
|
175 |
} |
a60bed296
|
176 177 178 179 180 181 182 183 184 185 |
/** * freezer_fork - cgroup post fork callback * @task: a task which has just been forked * * @task has just been created and should conform to the current state of * the cgroup_freezer it belongs to. This function may race against * freezer_attach(). Losing to freezer_attach() means that we don't have * to do anything as freezer_attach() will put @task into the appropriate * state. */ |
b53202e63
|
186 |
static void freezer_fork(struct task_struct *task) |
dc52ddc0e
|
187 188 |
{ struct freezer *freezer; |
3b1b3f6e5
|
189 |
/* |
a60bed296
|
190 191 192 193 194 |
* The root cgroup is non-freezable, so we can skip locking the * freezer. This is safe regardless of race with task migration. * If we didn't race or won, skipping is obviously the right thing * to do. If we lost and root is the new cgroup, noop is still the * right thing to do. |
3b1b3f6e5
|
195 |
*/ |
e5ced8ebb
|
196 197 |
if (task_css_is_root(task, freezer_cgrp_id)) return; |
3b1b3f6e5
|
198 |
|
e5ced8ebb
|
199 200 201 202 203 |
mutex_lock(&freezer_mutex); rcu_read_lock(); freezer = task_freezer(task); if (freezer->state & CGROUP_FREEZING) |
839e3407d
|
204 |
freeze_task(task); |
e5ced8ebb
|
205 |
|
5edee61ed
|
206 |
rcu_read_unlock(); |
e5ced8ebb
|
207 |
mutex_unlock(&freezer_mutex); |
dc52ddc0e
|
208 |
} |
ef9fe980c
|
209 210 |
/** * update_if_frozen - update whether a cgroup finished freezing |
182446d08
|
211 |
* @css: css of interest |
ef9fe980c
|
212 213 214 215 216 217 218 219 |
* * Once FREEZING is initiated, transition to FROZEN is lazily updated by * calling this function. If the current state is FREEZING but not FROZEN, * this function checks whether all tasks of this cgroup and the descendant * cgroups finished freezing and, if so, sets FROZEN. * * The caller is responsible for grabbing RCU read lock and calling * update_if_frozen() on all descendants prior to invoking this function. |
b4d18311d
|
220 221 |
* * Task states and freezer state might disagree while tasks are being |
182446d08
|
222 |
* migrated into or out of @css, so we can't verify task states against |
ead5c4737
|
223 |
* @freezer state here. See freezer_attach() for details. |
dc52ddc0e
|
224 |
*/ |
182446d08
|
225 |
static void update_if_frozen(struct cgroup_subsys_state *css) |
dc52ddc0e
|
226 |
{ |
182446d08
|
227 |
struct freezer *freezer = css_freezer(css); |
492eb21b9
|
228 |
struct cgroup_subsys_state *pos; |
72ec70299
|
229 |
struct css_task_iter it; |
dc52ddc0e
|
230 |
struct task_struct *task; |
b4d18311d
|
231 |
|
e5ced8ebb
|
232 |
lockdep_assert_held(&freezer_mutex); |
ef9fe980c
|
233 |
|
d6a2fe134
|
234 235 |
if (!(freezer->state & CGROUP_FREEZING) || (freezer->state & CGROUP_FROZEN)) |
e5ced8ebb
|
236 |
return; |
ef9fe980c
|
237 238 |
/* are all (live) children frozen? */ |
e5ced8ebb
|
239 |
rcu_read_lock(); |
492eb21b9
|
240 241 |
css_for_each_child(pos, css) { struct freezer *child = css_freezer(pos); |
dc52ddc0e
|
242 |
|
ef9fe980c
|
243 |
if ((child->state & CGROUP_FREEZER_ONLINE) && |
36e9d2ebc
|
244 245 |
!(child->state & CGROUP_FROZEN)) { rcu_read_unlock(); |
e5ced8ebb
|
246 |
return; |
36e9d2ebc
|
247 |
} |
ef9fe980c
|
248 |
} |
e5ced8ebb
|
249 |
rcu_read_unlock(); |
ef9fe980c
|
250 251 |
/* are all tasks frozen? */ |
72ec70299
|
252 |
css_task_iter_start(css, &it); |
b4d18311d
|
253 |
|
72ec70299
|
254 |
while ((task = css_task_iter_next(&it))) { |
3c426d5e1
|
255 |
if (freezing(task)) { |
3c426d5e1
|
256 257 258 259 260 261 |
/* * freezer_should_skip() indicates that the task * should be skipped when determining freezing * completion. Consider it frozen in addition to * the usual frozen condition. */ |
5d8f72b55
|
262 |
if (!frozen(task) && !freezer_should_skip(task)) |
ef9fe980c
|
263 |
goto out_iter_end; |
3c426d5e1
|
264 |
} |
dc52ddc0e
|
265 |
} |
d6a2fe134
|
266 |
freezer->state |= CGROUP_FROZEN; |
ef9fe980c
|
267 |
out_iter_end: |
72ec70299
|
268 |
css_task_iter_end(&it); |
dc52ddc0e
|
269 |
} |
2da8ca822
|
270 |
static int freezer_read(struct seq_file *m, void *v) |
dc52ddc0e
|
271 |
{ |
2da8ca822
|
272 |
struct cgroup_subsys_state *css = seq_css(m), *pos; |
dc52ddc0e
|
273 |
|
e5ced8ebb
|
274 |
mutex_lock(&freezer_mutex); |
ef9fe980c
|
275 |
rcu_read_lock(); |
dc52ddc0e
|
276 |
|
ef9fe980c
|
277 |
/* update states bottom-up */ |
e5ced8ebb
|
278 |
css_for_each_descendant_post(pos, css) { |
ec903c0c8
|
279 |
if (!css_tryget_online(pos)) |
e5ced8ebb
|
280 281 |
continue; rcu_read_unlock(); |
492eb21b9
|
282 |
update_if_frozen(pos); |
ef9fe980c
|
283 |
|
e5ced8ebb
|
284 285 286 |
rcu_read_lock(); css_put(pos); } |
ef9fe980c
|
287 |
rcu_read_unlock(); |
e5ced8ebb
|
288 |
mutex_unlock(&freezer_mutex); |
ef9fe980c
|
289 |
|
182446d08
|
290 |
seq_puts(m, freezer_state_strs(css_freezer(css)->state)); |
dc52ddc0e
|
291 292 293 294 |
seq_putc(m, ' '); return 0; } |
bcd66c894
|
295 |
static void freeze_cgroup(struct freezer *freezer) |
dc52ddc0e
|
296 |
{ |
72ec70299
|
297 |
struct css_task_iter it; |
dc52ddc0e
|
298 |
struct task_struct *task; |
dc52ddc0e
|
299 |
|
72ec70299
|
300 301 |
css_task_iter_start(&freezer->css, &it); while ((task = css_task_iter_next(&it))) |
51f246ed9
|
302 |
freeze_task(task); |
72ec70299
|
303 |
css_task_iter_end(&it); |
dc52ddc0e
|
304 |
} |
bcd66c894
|
305 |
static void unfreeze_cgroup(struct freezer *freezer) |
dc52ddc0e
|
306 |
{ |
72ec70299
|
307 |
struct css_task_iter it; |
dc52ddc0e
|
308 |
struct task_struct *task; |
72ec70299
|
309 310 |
css_task_iter_start(&freezer->css, &it); while ((task = css_task_iter_next(&it))) |
a5be2d0d1
|
311 |
__thaw_task(task); |
72ec70299
|
312 |
css_task_iter_end(&it); |
dc52ddc0e
|
313 |
} |
04a4ec325
|
314 315 316 317 |
/** * freezer_apply_state - apply state change to a single cgroup_freezer * @freezer: freezer to apply state change to * @freeze: whether to freeze or unfreeze |
a22521806
|
318 319 320 321 |
* @state: CGROUP_FREEZING_* flag to set or clear * * Set or clear @state on @cgroup according to @freeze, and perform * freezing or thawing as necessary. |
04a4ec325
|
322 |
*/ |
a22521806
|
323 324 |
static void freezer_apply_state(struct freezer *freezer, bool freeze, unsigned int state) |
dc52ddc0e
|
325 |
{ |
ead5c4737
|
326 |
/* also synchronizes against task migration, see freezer_attach() */ |
e5ced8ebb
|
327 |
lockdep_assert_held(&freezer_mutex); |
51308ee59
|
328 |
|
5300a9b34
|
329 330 |
if (!(freezer->state & CGROUP_FREEZER_ONLINE)) return; |
04a4ec325
|
331 |
if (freeze) { |
d6a2fe134
|
332 |
if (!(freezer->state & CGROUP_FREEZING)) |
a3201227f
|
333 |
atomic_inc(&system_freezing_cnt); |
a22521806
|
334 |
freezer->state |= state; |
bcd66c894
|
335 |
freeze_cgroup(freezer); |
04a4ec325
|
336 |
} else { |
a22521806
|
337 338 339 340 341 342 343 344 345 346 |
bool was_freezing = freezer->state & CGROUP_FREEZING; freezer->state &= ~state; if (!(freezer->state & CGROUP_FREEZING)) { if (was_freezing) atomic_dec(&system_freezing_cnt); freezer->state &= ~CGROUP_FROZEN; unfreeze_cgroup(freezer); } |
dc52ddc0e
|
347 |
} |
04a4ec325
|
348 |
} |
22b4e111f
|
349 |
|
04a4ec325
|
350 351 352 353 354 |
/** * freezer_change_state - change the freezing state of a cgroup_freezer * @freezer: freezer of interest * @freeze: whether to freeze or thaw * |
ef9fe980c
|
355 356 |
* Freeze or thaw @freezer according to @freeze. The operations are * recursive - all descendants of @freezer will be affected. |
04a4ec325
|
357 358 359 |
*/ static void freezer_change_state(struct freezer *freezer, bool freeze) { |
492eb21b9
|
360 |
struct cgroup_subsys_state *pos; |
ef9fe980c
|
361 |
|
ef9fe980c
|
362 363 364 365 366 |
/* * Update all its descendants in pre-order traversal. Each * descendant will try to inherit its parent's FREEZING state as * CGROUP_FREEZING_PARENT. */ |
e5ced8ebb
|
367 |
mutex_lock(&freezer_mutex); |
ef9fe980c
|
368 |
rcu_read_lock(); |
492eb21b9
|
369 370 |
css_for_each_descendant_pre(pos, &freezer->css) { struct freezer *pos_f = css_freezer(pos); |
ef9fe980c
|
371 |
struct freezer *parent = parent_freezer(pos_f); |
ec903c0c8
|
372 |
if (!css_tryget_online(pos)) |
e5ced8ebb
|
373 374 |
continue; rcu_read_unlock(); |
bd8815a6d
|
375 |
|
e5ced8ebb
|
376 |
if (pos_f == freezer) |
bd8815a6d
|
377 378 |
freezer_apply_state(pos_f, freeze, CGROUP_FREEZING_SELF); |
e5ced8ebb
|
379 |
else |
bd8815a6d
|
380 381 382 |
freezer_apply_state(pos_f, parent->state & CGROUP_FREEZING, CGROUP_FREEZING_PARENT); |
bd8815a6d
|
383 |
|
e5ced8ebb
|
384 385 |
rcu_read_lock(); css_put(pos); |
ef9fe980c
|
386 387 |
} rcu_read_unlock(); |
e5ced8ebb
|
388 |
mutex_unlock(&freezer_mutex); |
dc52ddc0e
|
389 |
} |
451af504d
|
390 391 |
static ssize_t freezer_write(struct kernfs_open_file *of, char *buf, size_t nbytes, loff_t off) |
dc52ddc0e
|
392 |
{ |
04a4ec325
|
393 |
bool freeze; |
dc52ddc0e
|
394 |
|
451af504d
|
395 396 397 |
buf = strstrip(buf); if (strcmp(buf, freezer_state_strs(0)) == 0) |
04a4ec325
|
398 |
freeze = false; |
451af504d
|
399 |
else if (strcmp(buf, freezer_state_strs(CGROUP_FROZEN)) == 0) |
04a4ec325
|
400 |
freeze = true; |
dc52ddc0e
|
401 |
else |
3b1b3f6e5
|
402 |
return -EINVAL; |
dc52ddc0e
|
403 |
|
451af504d
|
404 405 |
freezer_change_state(css_freezer(of_css(of)), freeze); return nbytes; |
dc52ddc0e
|
406 |
} |
182446d08
|
407 408 |
static u64 freezer_self_freezing_read(struct cgroup_subsys_state *css, struct cftype *cft) |
a22521806
|
409 |
{ |
182446d08
|
410 |
struct freezer *freezer = css_freezer(css); |
a22521806
|
411 412 413 |
return (bool)(freezer->state & CGROUP_FREEZING_SELF); } |
182446d08
|
414 415 |
static u64 freezer_parent_freezing_read(struct cgroup_subsys_state *css, struct cftype *cft) |
a22521806
|
416 |
{ |
182446d08
|
417 |
struct freezer *freezer = css_freezer(css); |
a22521806
|
418 419 420 |
return (bool)(freezer->state & CGROUP_FREEZING_PARENT); } |
dc52ddc0e
|
421 422 423 |
static struct cftype files[] = { { .name = "state", |
4baf6e332
|
424 |
.flags = CFTYPE_NOT_ON_ROOT, |
2da8ca822
|
425 |
.seq_show = freezer_read, |
451af504d
|
426 |
.write = freezer_write, |
dc52ddc0e
|
427 |
}, |
a22521806
|
428 429 430 431 432 433 434 435 436 437 |
{ .name = "self_freezing", .flags = CFTYPE_NOT_ON_ROOT, .read_u64 = freezer_self_freezing_read, }, { .name = "parent_freezing", .flags = CFTYPE_NOT_ON_ROOT, .read_u64 = freezer_parent_freezing_read, }, |
4baf6e332
|
438 |
{ } /* terminate */ |
dc52ddc0e
|
439 |
}; |
073219e99
|
440 |
struct cgroup_subsys freezer_cgrp_subsys = { |
92fb97487
|
441 442 443 444 |
.css_alloc = freezer_css_alloc, .css_online = freezer_css_online, .css_offline = freezer_css_offline, .css_free = freezer_css_free, |
8755ade68
|
445 |
.attach = freezer_attach, |
dc52ddc0e
|
446 |
.fork = freezer_fork, |
5577964e6
|
447 |
.legacy_cftypes = files, |
dc52ddc0e
|
448 |
}; |