Root/kernel/cgroup_freezer.c

1/*
2 * cgroup_freezer.c - control group freezer subsystem
3 *
4 * Copyright IBM Corporation, 2007
5 *
6 * Author : Cedric Le Goater <clg@fr.ibm.com>
7 *
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.
11 *
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.
15 */
16
17#include <linux/module.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
25enum freezer_state {
26    CGROUP_THAWED = 0,
27    CGROUP_FREEZING,
28    CGROUP_FROZEN,
29};
30
31struct freezer {
32    struct cgroup_subsys_state css;
33    enum freezer_state state;
34    spinlock_t lock; /* protects _writes_ to state */
35};
36
37static inline struct freezer *cgroup_freezer(
38        struct cgroup *cgroup)
39{
40    return container_of(
41        cgroup_subsys_state(cgroup, freezer_subsys_id),
42        struct freezer, css);
43}
44
45static inline struct freezer *task_freezer(struct task_struct *task)
46{
47    return container_of(task_subsys_state(task, freezer_subsys_id),
48                struct freezer, css);
49}
50
51int cgroup_freezing_or_frozen(struct task_struct *task)
52{
53    struct freezer *freezer;
54    enum freezer_state state;
55
56    task_lock(task);
57    freezer = task_freezer(task);
58    if (!freezer->css.cgroup->parent)
59        state = CGROUP_THAWED; /* root cgroup can't be frozen */
60    else
61        state = freezer->state;
62    task_unlock(task);
63
64    return (state == CGROUP_FREEZING) || (state == CGROUP_FROZEN);
65}
66
67/*
68 * cgroups_write_string() limits the size of freezer state strings to
69 * CGROUP_LOCAL_BUFFER_SIZE
70 */
71static const char *freezer_state_strs[] = {
72    "THAWED",
73    "FREEZING",
74    "FROZEN",
75};
76
77/*
78 * State diagram
79 * Transitions are caused by userspace writes to the freezer.state file.
80 * The values in parenthesis are state labels. The rest are edge labels.
81 *
82 * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
83 * ^ ^ | |
84 * | \_______THAWED_______/ |
85 * \__________________________THAWED____________/
86 */
87
88struct cgroup_subsys freezer_subsys;
89
90/* Locks taken and their ordering
91 * ------------------------------
92 * css_set_lock
93 * cgroup_mutex (AKA cgroup_lock)
94 * task->alloc_lock (AKA task_lock)
95 * freezer->lock
96 * task->sighand->siglock
97 *
98 * cgroup code forces css_set_lock to be taken before task->alloc_lock
99 *
100 * freezer_create(), freezer_destroy():
101 * cgroup_mutex [ by cgroup core ]
102 *
103 * can_attach():
104 * cgroup_mutex
105 *
106 * cgroup_frozen():
107 * task->alloc_lock (to get task's cgroup)
108 *
109 * freezer_fork() (preserving fork() performance means can't take cgroup_mutex):
110 * task->alloc_lock (to get task's cgroup)
111 * freezer->lock
112 * sighand->siglock (if the cgroup is freezing)
113 *
114 * freezer_read():
115 * cgroup_mutex
116 * freezer->lock
117 * read_lock css_set_lock (cgroup iterator start)
118 *
119 * freezer_write() (freeze):
120 * cgroup_mutex
121 * freezer->lock
122 * read_lock css_set_lock (cgroup iterator start)
123 * sighand->siglock
124 *
125 * freezer_write() (unfreeze):
126 * cgroup_mutex
127 * freezer->lock
128 * read_lock css_set_lock (cgroup iterator start)
129 * task->alloc_lock (to prevent races with freeze_task())
130 * sighand->siglock
131 */
132static struct cgroup_subsys_state *freezer_create(struct cgroup_subsys *ss,
133                          struct cgroup *cgroup)
134{
135    struct freezer *freezer;
136
137    freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
138    if (!freezer)
139        return ERR_PTR(-ENOMEM);
140
141    spin_lock_init(&freezer->lock);
142    freezer->state = CGROUP_THAWED;
143    return &freezer->css;
144}
145
146static void freezer_destroy(struct cgroup_subsys *ss,
147                struct cgroup *cgroup)
148{
149    kfree(cgroup_freezer(cgroup));
150}
151
152/* Task is frozen or will freeze immediately when next it gets woken */
153static bool is_task_frozen_enough(struct task_struct *task)
154{
155    return frozen(task) ||
156        (task_is_stopped_or_traced(task) && freezing(task));
157}
158
159/*
160 * The call to cgroup_lock() in the freezer.state write method prevents
161 * a write to that file racing against an attach, and hence the
162 * can_attach() result will remain valid until the attach completes.
163 */
164static int freezer_can_attach(struct cgroup_subsys *ss,
165                  struct cgroup *new_cgroup,
166                  struct task_struct *task, bool threadgroup)
167{
168    struct freezer *freezer;
169
170    /*
171     * Anything frozen can't move or be moved to/from.
172     *
173     * Since orig_freezer->state == FROZEN means that @task has been
174     * frozen, so it's sufficient to check the latter condition.
175     */
176
177    if (is_task_frozen_enough(task))
178        return -EBUSY;
179
180    freezer = cgroup_freezer(new_cgroup);
181    if (freezer->state == CGROUP_FROZEN)
182        return -EBUSY;
183
184    if (threadgroup) {
185        struct task_struct *c;
186
187        rcu_read_lock();
188        list_for_each_entry_rcu(c, &task->thread_group, thread_group) {
189            if (is_task_frozen_enough(c)) {
190                rcu_read_unlock();
191                return -EBUSY;
192            }
193        }
194        rcu_read_unlock();
195    }
196
197    return 0;
198}
199
200static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
201{
202    struct freezer *freezer;
203
204    /*
205     * No lock is needed, since the task isn't on tasklist yet,
206     * so it can't be moved to another cgroup, which means the
207     * freezer won't be removed and will be valid during this
208     * function call.
209     */
210    freezer = task_freezer(task);
211
212    /*
213     * The root cgroup is non-freezable, so we can skip the
214     * following check.
215     */
216    if (!freezer->css.cgroup->parent)
217        return;
218
219    spin_lock_irq(&freezer->lock);
220    BUG_ON(freezer->state == CGROUP_FROZEN);
221
222    /* Locking avoids race with FREEZING -> THAWED transitions. */
223    if (freezer->state == CGROUP_FREEZING)
224        freeze_task(task, true);
225    spin_unlock_irq(&freezer->lock);
226}
227
228/*
229 * caller must hold freezer->lock
230 */
231static void update_freezer_state(struct cgroup *cgroup,
232                 struct freezer *freezer)
233{
234    struct cgroup_iter it;
235    struct task_struct *task;
236    unsigned int nfrozen = 0, ntotal = 0;
237
238    cgroup_iter_start(cgroup, &it);
239    while ((task = cgroup_iter_next(cgroup, &it))) {
240        ntotal++;
241        if (is_task_frozen_enough(task))
242            nfrozen++;
243    }
244
245    /*
246     * Transition to FROZEN when no new tasks can be added ensures
247     * that we never exist in the FROZEN state while there are unfrozen
248     * tasks.
249     */
250    if (nfrozen == ntotal)
251        freezer->state = CGROUP_FROZEN;
252    else if (nfrozen > 0)
253        freezer->state = CGROUP_FREEZING;
254    else
255        freezer->state = CGROUP_THAWED;
256    cgroup_iter_end(cgroup, &it);
257}
258
259static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
260            struct seq_file *m)
261{
262    struct freezer *freezer;
263    enum freezer_state state;
264
265    if (!cgroup_lock_live_group(cgroup))
266        return -ENODEV;
267
268    freezer = cgroup_freezer(cgroup);
269    spin_lock_irq(&freezer->lock);
270    state = freezer->state;
271    if (state == CGROUP_FREEZING) {
272        /* We change from FREEZING to FROZEN lazily if the cgroup was
273         * only partially frozen when we exitted write. */
274        update_freezer_state(cgroup, freezer);
275        state = freezer->state;
276    }
277    spin_unlock_irq(&freezer->lock);
278    cgroup_unlock();
279
280    seq_puts(m, freezer_state_strs[state]);
281    seq_putc(m, '\n');
282    return 0;
283}
284
285static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
286{
287    struct cgroup_iter it;
288    struct task_struct *task;
289    unsigned int num_cant_freeze_now = 0;
290
291    freezer->state = CGROUP_FREEZING;
292    cgroup_iter_start(cgroup, &it);
293    while ((task = cgroup_iter_next(cgroup, &it))) {
294        if (!freeze_task(task, true))
295            continue;
296        if (is_task_frozen_enough(task))
297            continue;
298        if (!freezing(task) && !freezer_should_skip(task))
299            num_cant_freeze_now++;
300    }
301    cgroup_iter_end(cgroup, &it);
302
303    return num_cant_freeze_now ? -EBUSY : 0;
304}
305
306static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
307{
308    struct cgroup_iter it;
309    struct task_struct *task;
310
311    cgroup_iter_start(cgroup, &it);
312    while ((task = cgroup_iter_next(cgroup, &it))) {
313        thaw_process(task);
314    }
315    cgroup_iter_end(cgroup, &it);
316
317    freezer->state = CGROUP_THAWED;
318}
319
320static int freezer_change_state(struct cgroup *cgroup,
321                enum freezer_state goal_state)
322{
323    struct freezer *freezer;
324    int retval = 0;
325
326    freezer = cgroup_freezer(cgroup);
327
328    spin_lock_irq(&freezer->lock);
329
330    update_freezer_state(cgroup, freezer);
331    if (goal_state == freezer->state)
332        goto out;
333
334    switch (goal_state) {
335    case CGROUP_THAWED:
336        unfreeze_cgroup(cgroup, freezer);
337        break;
338    case CGROUP_FROZEN:
339        retval = try_to_freeze_cgroup(cgroup, freezer);
340        break;
341    default:
342        BUG();
343    }
344out:
345    spin_unlock_irq(&freezer->lock);
346
347    return retval;
348}
349
350static int freezer_write(struct cgroup *cgroup,
351             struct cftype *cft,
352             const char *buffer)
353{
354    int retval;
355    enum freezer_state goal_state;
356
357    if (strcmp(buffer, freezer_state_strs[CGROUP_THAWED]) == 0)
358        goal_state = CGROUP_THAWED;
359    else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
360        goal_state = CGROUP_FROZEN;
361    else
362        return -EINVAL;
363
364    if (!cgroup_lock_live_group(cgroup))
365        return -ENODEV;
366    retval = freezer_change_state(cgroup, goal_state);
367    cgroup_unlock();
368    return retval;
369}
370
371static struct cftype files[] = {
372    {
373        .name = "state",
374        .read_seq_string = freezer_read,
375        .write_string = freezer_write,
376    },
377};
378
379static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
380{
381    if (!cgroup->parent)
382        return 0;
383    return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
384}
385
386struct cgroup_subsys freezer_subsys = {
387    .name = "freezer",
388    .create = freezer_create,
389    .destroy = freezer_destroy,
390    .populate = freezer_populate,
391    .subsys_id = freezer_subsys_id,
392    .can_attach = freezer_can_attach,
393    .attach = NULL,
394    .fork = freezer_fork,
395    .exit = NULL,
396};
397

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive