2 * cgroup_freezer.c - control group freezer subsystem
4 * Copyright IBM Corporation, 2007
6 * Author : Cedric Le Goater <clg@fr.ibm.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of version 2.1 of the GNU Lesser General Public License
10 * as published by the Free Software Foundation.
12 * This program is distributed in the hope that it would be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 #include <linux/export.h>
18 #include <linux/slab.h>
19 #include <linux/cgroup.h>
21 #include <linux/uaccess.h>
22 #include <linux/freezer.h>
23 #include <linux/seq_file.h>
24 #include <linux/mutex.h>
27 * A cgroup is freezing if any FREEZING flags are set. FREEZING_SELF is
28 * set if "FROZEN" is written to freezer.state cgroupfs file, and cleared
29 * for "THAWED". FREEZING_PARENT is set if the parent freezer is FREEZING
30 * for whatever reason. IOW, a cgroup has FREEZING_PARENT set if one of
31 * its ancestors has FREEZING_SELF set.
33 enum freezer_state_flags
{
34 CGROUP_FREEZER_ONLINE
= (1 << 0), /* freezer is fully online */
35 CGROUP_FREEZING_SELF
= (1 << 1), /* this freezer is freezing */
36 CGROUP_FREEZING_PARENT
= (1 << 2), /* the parent freezer is freezing */
37 CGROUP_FROZEN
= (1 << 3), /* this and its descendants frozen */
39 /* mask for all FREEZING flags */
40 CGROUP_FREEZING
= CGROUP_FREEZING_SELF
| CGROUP_FREEZING_PARENT
,
44 struct cgroup_subsys_state css
;
48 static DEFINE_MUTEX(freezer_mutex
);
50 static inline struct freezer
*css_freezer(struct cgroup_subsys_state
*css
)
52 return css
? container_of(css
, struct freezer
, css
) : NULL
;
55 static inline struct freezer
*task_freezer(struct task_struct
*task
)
57 return css_freezer(task_css(task
, freezer_cgrp_id
));
60 static struct freezer
*parent_freezer(struct freezer
*freezer
)
62 return css_freezer(css_parent(&freezer
->css
));
65 bool cgroup_freezing(struct task_struct
*task
)
70 ret
= task_freezer(task
)->state
& CGROUP_FREEZING
;
77 * cgroups_write_string() limits the size of freezer state strings to
78 * CGROUP_LOCAL_BUFFER_SIZE
80 static const char *freezer_state_strs(unsigned int state
)
82 if (state
& CGROUP_FROZEN
)
84 if (state
& CGROUP_FREEZING
)
89 static struct cgroup_subsys_state
*
90 freezer_css_alloc(struct cgroup_subsys_state
*parent_css
)
92 struct freezer
*freezer
;
94 freezer
= kzalloc(sizeof(struct freezer
), GFP_KERNEL
);
96 return ERR_PTR(-ENOMEM
);
102 * freezer_css_online - commit creation of a freezer css
103 * @css: css being created
105 * We're committing to creation of @css. Mark it online and inherit
106 * parent's freezing state while holding both parent's and our
109 static int freezer_css_online(struct cgroup_subsys_state
*css
)
111 struct freezer
*freezer
= css_freezer(css
);
112 struct freezer
*parent
= parent_freezer(freezer
);
114 mutex_lock(&freezer_mutex
);
116 freezer
->state
|= CGROUP_FREEZER_ONLINE
;
118 if (parent
&& (parent
->state
& CGROUP_FREEZING
)) {
119 freezer
->state
|= CGROUP_FREEZING_PARENT
| CGROUP_FROZEN
;
120 atomic_inc(&system_freezing_cnt
);
123 mutex_unlock(&freezer_mutex
);
128 * freezer_css_offline - initiate destruction of a freezer css
129 * @css: css being destroyed
131 * @css is going away. Mark it dead and decrement system_freezing_count if
132 * it was holding one.
134 static void freezer_css_offline(struct cgroup_subsys_state
*css
)
136 struct freezer
*freezer
= css_freezer(css
);
138 mutex_lock(&freezer_mutex
);
140 if (freezer
->state
& CGROUP_FREEZING
)
141 atomic_dec(&system_freezing_cnt
);
145 mutex_unlock(&freezer_mutex
);
148 static void freezer_css_free(struct cgroup_subsys_state
*css
)
150 kfree(css_freezer(css
));
154 * Tasks can be migrated into a different freezer anytime regardless of its
155 * current state. freezer_attach() is responsible for making new tasks
156 * conform to the current state.
158 * Freezer state changes and task migration are synchronized via
159 * @freezer->lock. freezer_attach() makes the new tasks conform to the
160 * current state and all following state changes can see the new tasks.
162 static void freezer_attach(struct cgroup_subsys_state
*new_css
,
163 struct cgroup_taskset
*tset
)
165 struct freezer
*freezer
= css_freezer(new_css
);
166 struct task_struct
*task
;
167 bool clear_frozen
= false;
169 mutex_lock(&freezer_mutex
);
172 * Make the new tasks conform to the current state of @new_css.
173 * For simplicity, when migrating any task to a FROZEN cgroup, we
174 * revert it to FREEZING and let update_if_frozen() determine the
175 * correct state later.
177 * Tasks in @tset are on @new_css but may not conform to its
178 * current state before executing the following - !frozen tasks may
179 * be visible in a FROZEN cgroup and frozen tasks in a THAWED one.
181 cgroup_taskset_for_each(task
, tset
) {
182 if (!(freezer
->state
& CGROUP_FREEZING
)) {
186 freezer
->state
&= ~CGROUP_FROZEN
;
191 /* propagate FROZEN clearing upwards */
192 while (clear_frozen
&& (freezer
= parent_freezer(freezer
))) {
193 freezer
->state
&= ~CGROUP_FROZEN
;
194 clear_frozen
= freezer
->state
& CGROUP_FREEZING
;
197 mutex_unlock(&freezer_mutex
);
201 * freezer_fork - cgroup post fork callback
202 * @task: a task which has just been forked
204 * @task has just been created and should conform to the current state of
205 * the cgroup_freezer it belongs to. This function may race against
206 * freezer_attach(). Losing to freezer_attach() means that we don't have
207 * to do anything as freezer_attach() will put @task into the appropriate
210 static void freezer_fork(struct task_struct
*task
)
212 struct freezer
*freezer
;
215 * The root cgroup is non-freezable, so we can skip locking the
216 * freezer. This is safe regardless of race with task migration.
217 * If we didn't race or won, skipping is obviously the right thing
218 * to do. If we lost and root is the new cgroup, noop is still the
221 if (task_css_is_root(task
, freezer_cgrp_id
))
224 mutex_lock(&freezer_mutex
);
227 freezer
= task_freezer(task
);
228 if (freezer
->state
& CGROUP_FREEZING
)
232 mutex_unlock(&freezer_mutex
);
236 * update_if_frozen - update whether a cgroup finished freezing
237 * @css: css of interest
239 * Once FREEZING is initiated, transition to FROZEN is lazily updated by
240 * calling this function. If the current state is FREEZING but not FROZEN,
241 * this function checks whether all tasks of this cgroup and the descendant
242 * cgroups finished freezing and, if so, sets FROZEN.
244 * The caller is responsible for grabbing RCU read lock and calling
245 * update_if_frozen() on all descendants prior to invoking this function.
247 * Task states and freezer state might disagree while tasks are being
248 * migrated into or out of @css, so we can't verify task states against
249 * @freezer state here. See freezer_attach() for details.
251 static void update_if_frozen(struct cgroup_subsys_state
*css
)
253 struct freezer
*freezer
= css_freezer(css
);
254 struct cgroup_subsys_state
*pos
;
255 struct css_task_iter it
;
256 struct task_struct
*task
;
258 lockdep_assert_held(&freezer_mutex
);
260 if (!(freezer
->state
& CGROUP_FREEZING
) ||
261 (freezer
->state
& CGROUP_FROZEN
))
264 /* are all (live) children frozen? */
266 css_for_each_child(pos
, css
) {
267 struct freezer
*child
= css_freezer(pos
);
269 if ((child
->state
& CGROUP_FREEZER_ONLINE
) &&
270 !(child
->state
& CGROUP_FROZEN
)) {
277 /* are all tasks frozen? */
278 css_task_iter_start(css
, &it
);
280 while ((task
= css_task_iter_next(&it
))) {
281 if (freezing(task
)) {
283 * freezer_should_skip() indicates that the task
284 * should be skipped when determining freezing
285 * completion. Consider it frozen in addition to
286 * the usual frozen condition.
288 if (!frozen(task
) && !freezer_should_skip(task
))
293 freezer
->state
|= CGROUP_FROZEN
;
295 css_task_iter_end(&it
);
298 static int freezer_read(struct seq_file
*m
, void *v
)
300 struct cgroup_subsys_state
*css
= seq_css(m
), *pos
;
302 mutex_lock(&freezer_mutex
);
305 /* update states bottom-up */
306 css_for_each_descendant_post(pos
, css
) {
307 if (!css_tryget(pos
))
311 update_if_frozen(pos
);
318 mutex_unlock(&freezer_mutex
);
320 seq_puts(m
, freezer_state_strs(css_freezer(css
)->state
));
325 static void freeze_cgroup(struct freezer
*freezer
)
327 struct css_task_iter it
;
328 struct task_struct
*task
;
330 css_task_iter_start(&freezer
->css
, &it
);
331 while ((task
= css_task_iter_next(&it
)))
333 css_task_iter_end(&it
);
336 static void unfreeze_cgroup(struct freezer
*freezer
)
338 struct css_task_iter it
;
339 struct task_struct
*task
;
341 css_task_iter_start(&freezer
->css
, &it
);
342 while ((task
= css_task_iter_next(&it
)))
344 css_task_iter_end(&it
);
348 * freezer_apply_state - apply state change to a single cgroup_freezer
349 * @freezer: freezer to apply state change to
350 * @freeze: whether to freeze or unfreeze
351 * @state: CGROUP_FREEZING_* flag to set or clear
353 * Set or clear @state on @cgroup according to @freeze, and perform
354 * freezing or thawing as necessary.
356 static void freezer_apply_state(struct freezer
*freezer
, bool freeze
,
359 /* also synchronizes against task migration, see freezer_attach() */
360 lockdep_assert_held(&freezer_mutex
);
362 if (!(freezer
->state
& CGROUP_FREEZER_ONLINE
))
366 if (!(freezer
->state
& CGROUP_FREEZING
))
367 atomic_inc(&system_freezing_cnt
);
368 freezer
->state
|= state
;
369 freeze_cgroup(freezer
);
371 bool was_freezing
= freezer
->state
& CGROUP_FREEZING
;
373 freezer
->state
&= ~state
;
375 if (!(freezer
->state
& CGROUP_FREEZING
)) {
377 atomic_dec(&system_freezing_cnt
);
378 freezer
->state
&= ~CGROUP_FROZEN
;
379 unfreeze_cgroup(freezer
);
385 * freezer_change_state - change the freezing state of a cgroup_freezer
386 * @freezer: freezer of interest
387 * @freeze: whether to freeze or thaw
389 * Freeze or thaw @freezer according to @freeze. The operations are
390 * recursive - all descendants of @freezer will be affected.
392 static void freezer_change_state(struct freezer
*freezer
, bool freeze
)
394 struct cgroup_subsys_state
*pos
;
397 * Update all its descendants in pre-order traversal. Each
398 * descendant will try to inherit its parent's FREEZING state as
399 * CGROUP_FREEZING_PARENT.
401 mutex_lock(&freezer_mutex
);
403 css_for_each_descendant_pre(pos
, &freezer
->css
) {
404 struct freezer
*pos_f
= css_freezer(pos
);
405 struct freezer
*parent
= parent_freezer(pos_f
);
407 if (!css_tryget(pos
))
411 if (pos_f
== freezer
)
412 freezer_apply_state(pos_f
, freeze
,
413 CGROUP_FREEZING_SELF
);
415 freezer_apply_state(pos_f
,
416 parent
->state
& CGROUP_FREEZING
,
417 CGROUP_FREEZING_PARENT
);
423 mutex_unlock(&freezer_mutex
);
426 static int freezer_write(struct cgroup_subsys_state
*css
, struct cftype
*cft
,
431 if (strcmp(buffer
, freezer_state_strs(0)) == 0)
433 else if (strcmp(buffer
, freezer_state_strs(CGROUP_FROZEN
)) == 0)
438 freezer_change_state(css_freezer(css
), freeze
);
442 static u64
freezer_self_freezing_read(struct cgroup_subsys_state
*css
,
445 struct freezer
*freezer
= css_freezer(css
);
447 return (bool)(freezer
->state
& CGROUP_FREEZING_SELF
);
450 static u64
freezer_parent_freezing_read(struct cgroup_subsys_state
*css
,
453 struct freezer
*freezer
= css_freezer(css
);
455 return (bool)(freezer
->state
& CGROUP_FREEZING_PARENT
);
458 static struct cftype files
[] = {
461 .flags
= CFTYPE_NOT_ON_ROOT
,
462 .seq_show
= freezer_read
,
463 .write_string
= freezer_write
,
466 .name
= "self_freezing",
467 .flags
= CFTYPE_NOT_ON_ROOT
,
468 .read_u64
= freezer_self_freezing_read
,
471 .name
= "parent_freezing",
472 .flags
= CFTYPE_NOT_ON_ROOT
,
473 .read_u64
= freezer_parent_freezing_read
,
478 struct cgroup_subsys freezer_cgrp_subsys
= {
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 .attach
= freezer_attach
,
484 .fork
= freezer_fork
,
485 .base_cftypes
= files
,