Merge remote-tracking branch 'moduleh/module.h-split'
[linux-2.6/next.git] / kernel / cgroup_freezer.c
blobe8b405a942bf93d8d068422d55434f72bb169aca
1 /*
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>
20 #include <linux/fs.h>
21 #include <linux/uaccess.h>
22 #include <linux/freezer.h>
23 #include <linux/seq_file.h>
25 enum freezer_state {
26 CGROUP_THAWED = 0,
27 CGROUP_FREEZING,
28 CGROUP_FROZEN,
31 struct freezer {
32 struct cgroup_subsys_state css;
33 enum freezer_state state;
34 spinlock_t lock; /* protects _writes_ to state */
37 static inline struct freezer *cgroup_freezer(
38 struct cgroup *cgroup)
40 return container_of(
41 cgroup_subsys_state(cgroup, freezer_subsys_id),
42 struct freezer, css);
45 static inline struct freezer *task_freezer(struct task_struct *task)
47 return container_of(task_subsys_state(task, freezer_subsys_id),
48 struct freezer, css);
51 bool cgroup_freezing(struct task_struct *task)
53 enum freezer_state state;
54 bool ret;
56 rcu_read_lock();
57 state = task_freezer(task)->state;
58 ret = state == CGROUP_FREEZING || state == CGROUP_FROZEN;
59 rcu_read_unlock();
61 return ret;
65 * cgroups_write_string() limits the size of freezer state strings to
66 * CGROUP_LOCAL_BUFFER_SIZE
68 static const char *freezer_state_strs[] = {
69 "THAWED",
70 "FREEZING",
71 "FROZEN",
75 * State diagram
76 * Transitions are caused by userspace writes to the freezer.state file.
77 * The values in parenthesis are state labels. The rest are edge labels.
79 * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
80 * ^ ^ | |
81 * | \_______THAWED_______/ |
82 * \__________________________THAWED____________/
85 struct cgroup_subsys freezer_subsys;
87 /* Locks taken and their ordering
88 * ------------------------------
89 * cgroup_mutex (AKA cgroup_lock)
90 * freezer->lock
91 * css_set_lock
92 * task->alloc_lock (AKA task_lock)
93 * task->sighand->siglock
95 * cgroup code forces css_set_lock to be taken before task->alloc_lock
97 * freezer_create(), freezer_destroy():
98 * cgroup_mutex [ by cgroup core ]
100 * freezer_can_attach():
101 * cgroup_mutex (held by caller of can_attach)
103 * freezer_fork() (preserving fork() performance means can't take cgroup_mutex):
104 * freezer->lock
105 * sighand->siglock (if the cgroup is freezing)
107 * freezer_read():
108 * cgroup_mutex
109 * freezer->lock
110 * write_lock css_set_lock (cgroup iterator start)
111 * task->alloc_lock
112 * read_lock css_set_lock (cgroup iterator start)
114 * freezer_write() (freeze):
115 * cgroup_mutex
116 * freezer->lock
117 * write_lock css_set_lock (cgroup iterator start)
118 * task->alloc_lock
119 * read_lock css_set_lock (cgroup iterator start)
120 * sighand->siglock (fake signal delivery inside freeze_task())
122 * freezer_write() (unfreeze):
123 * cgroup_mutex
124 * freezer->lock
125 * write_lock css_set_lock (cgroup iterator start)
126 * task->alloc_lock
127 * read_lock css_set_lock (cgroup iterator start)
128 * task->alloc_lock (inside __thaw_task(), prevents race with refrigerator())
129 * sighand->siglock
131 static struct cgroup_subsys_state *freezer_create(struct cgroup_subsys *ss,
132 struct cgroup *cgroup)
134 struct freezer *freezer;
136 freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
137 if (!freezer)
138 return ERR_PTR(-ENOMEM);
140 spin_lock_init(&freezer->lock);
141 freezer->state = CGROUP_THAWED;
142 return &freezer->css;
145 static void freezer_destroy(struct cgroup_subsys *ss,
146 struct cgroup *cgroup)
148 struct freezer *freezer = cgroup_freezer(cgroup);
150 if (freezer->state != CGROUP_THAWED)
151 atomic_dec(&system_freezing_cnt);
152 kfree(freezer);
156 * The call to cgroup_lock() in the freezer.state write method prevents
157 * a write to that file racing against an attach, and hence the
158 * can_attach() result will remain valid until the attach completes.
160 static int freezer_can_attach(struct cgroup_subsys *ss,
161 struct cgroup *new_cgroup,
162 struct task_struct *task)
164 struct freezer *freezer;
167 * Anything frozen can't move or be moved to/from.
170 freezer = cgroup_freezer(new_cgroup);
171 if (freezer->state != CGROUP_THAWED)
172 return -EBUSY;
174 return 0;
177 static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
179 return cgroup_freezing(tsk) ? -EBUSY : 0;
182 static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
184 struct freezer *freezer;
187 * No lock is needed, since the task isn't on tasklist yet,
188 * so it can't be moved to another cgroup, which means the
189 * freezer won't be removed and will be valid during this
190 * function call. Nevertheless, apply RCU read-side critical
191 * section to suppress RCU lockdep false positives.
193 rcu_read_lock();
194 freezer = task_freezer(task);
195 rcu_read_unlock();
198 * The root cgroup is non-freezable, so we can skip the
199 * following check.
201 if (!freezer->css.cgroup->parent)
202 return;
204 spin_lock_irq(&freezer->lock);
205 BUG_ON(freezer->state == CGROUP_FROZEN);
207 /* Locking avoids race with FREEZING -> THAWED transitions. */
208 if (freezer->state == CGROUP_FREEZING)
209 freeze_task(task, true);
210 spin_unlock_irq(&freezer->lock);
214 * caller must hold freezer->lock
216 static void update_if_frozen(struct cgroup *cgroup,
217 struct freezer *freezer)
219 struct cgroup_iter it;
220 struct task_struct *task;
221 unsigned int nfrozen = 0, ntotal = 0;
222 enum freezer_state old_state = freezer->state;
224 cgroup_iter_start(cgroup, &it);
225 while ((task = cgroup_iter_next(cgroup, &it))) {
226 ntotal++;
227 if (frozen(task))
228 nfrozen++;
231 if (old_state == CGROUP_THAWED) {
232 BUG_ON(nfrozen > 0);
233 } else if (old_state == CGROUP_FREEZING) {
234 if (nfrozen == ntotal)
235 freezer->state = CGROUP_FROZEN;
236 } else { /* old_state == CGROUP_FROZEN */
237 BUG_ON(nfrozen != ntotal);
240 cgroup_iter_end(cgroup, &it);
243 static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
244 struct seq_file *m)
246 struct freezer *freezer;
247 enum freezer_state state;
249 if (!cgroup_lock_live_group(cgroup))
250 return -ENODEV;
252 freezer = cgroup_freezer(cgroup);
253 spin_lock_irq(&freezer->lock);
254 state = freezer->state;
255 if (state == CGROUP_FREEZING) {
256 /* We change from FREEZING to FROZEN lazily if the cgroup was
257 * only partially frozen when we exitted write. */
258 update_if_frozen(cgroup, freezer);
259 state = freezer->state;
261 spin_unlock_irq(&freezer->lock);
262 cgroup_unlock();
264 seq_puts(m, freezer_state_strs[state]);
265 seq_putc(m, '\n');
266 return 0;
269 static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
271 struct cgroup_iter it;
272 struct task_struct *task;
273 unsigned int num_cant_freeze_now = 0;
275 cgroup_iter_start(cgroup, &it);
276 while ((task = cgroup_iter_next(cgroup, &it))) {
277 if (!freeze_task(task, true))
278 continue;
279 if (frozen(task))
280 continue;
281 if (!freezing(task) && !freezer_should_skip(task))
282 num_cant_freeze_now++;
284 cgroup_iter_end(cgroup, &it);
286 return num_cant_freeze_now ? -EBUSY : 0;
289 static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
291 struct cgroup_iter it;
292 struct task_struct *task;
294 cgroup_iter_start(cgroup, &it);
295 while ((task = cgroup_iter_next(cgroup, &it)))
296 __thaw_task(task);
297 cgroup_iter_end(cgroup, &it);
300 static int freezer_change_state(struct cgroup *cgroup,
301 enum freezer_state goal_state)
303 struct freezer *freezer;
304 int retval = 0;
306 freezer = cgroup_freezer(cgroup);
308 spin_lock_irq(&freezer->lock);
310 update_if_frozen(cgroup, freezer);
311 if (goal_state == freezer->state)
312 goto out;
314 freezer->state = goal_state;
316 switch (goal_state) {
317 case CGROUP_THAWED:
318 atomic_dec(&system_freezing_cnt);
319 unfreeze_cgroup(cgroup, freezer);
320 break;
321 case CGROUP_FROZEN:
322 atomic_inc(&system_freezing_cnt);
323 retval = try_to_freeze_cgroup(cgroup, freezer);
324 break;
325 default:
326 BUG();
328 out:
329 spin_unlock_irq(&freezer->lock);
331 return retval;
334 static int freezer_write(struct cgroup *cgroup,
335 struct cftype *cft,
336 const char *buffer)
338 int retval;
339 enum freezer_state goal_state;
341 if (strcmp(buffer, freezer_state_strs[CGROUP_THAWED]) == 0)
342 goal_state = CGROUP_THAWED;
343 else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
344 goal_state = CGROUP_FROZEN;
345 else
346 return -EINVAL;
348 if (!cgroup_lock_live_group(cgroup))
349 return -ENODEV;
350 retval = freezer_change_state(cgroup, goal_state);
351 cgroup_unlock();
352 return retval;
355 static struct cftype files[] = {
357 .name = "state",
358 .read_seq_string = freezer_read,
359 .write_string = freezer_write,
363 static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
365 if (!cgroup->parent)
366 return 0;
367 return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
370 struct cgroup_subsys freezer_subsys = {
371 .name = "freezer",
372 .create = freezer_create,
373 .destroy = freezer_destroy,
374 .populate = freezer_populate,
375 .subsys_id = freezer_subsys_id,
376 .can_attach = freezer_can_attach,
377 .can_attach_task = freezer_can_attach_task,
378 .pre_attach = NULL,
379 .attach_task = NULL,
380 .attach = NULL,
381 .fork = freezer_fork,
382 .exit = NULL,