blob: e691818d7e450f5f8785b8b97a08cdbb2f4e1493 [file] [log] [blame]
Matt Helsleydc52ddc2008-10-18 20:27:21 -07001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090018#include <linux/slab.h>
Matt Helsleydc52ddc2008-10-18 20:27:21 -070019#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 {
Matt Helsley81dcf332008-10-18 20:27:23 -070026 CGROUP_THAWED = 0,
27 CGROUP_FREEZING,
28 CGROUP_FROZEN,
Matt Helsleydc52ddc2008-10-18 20:27:21 -070029};
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
Tomasz Buchertd5de4dd2010-10-27 15:33:32 -070051static inline int __cgroup_freezing_or_frozen(struct task_struct *task)
52{
53 enum freezer_state state = task_freezer(task)->state;
54 return (state == CGROUP_FREEZING) || (state == CGROUP_FROZEN);
55}
56
Matt Helsley5a7aadf2010-03-26 23:51:44 +010057int cgroup_freezing_or_frozen(struct task_struct *task)
Matt Helsleydc52ddc2008-10-18 20:27:21 -070058{
Tomasz Buchertd5de4dd2010-10-27 15:33:32 -070059 int result;
Matt Helsleydc52ddc2008-10-18 20:27:21 -070060 task_lock(task);
Tomasz Buchertd5de4dd2010-10-27 15:33:32 -070061 result = __cgroup_freezing_or_frozen(task);
Matt Helsleydc52ddc2008-10-18 20:27:21 -070062 task_unlock(task);
Tomasz Buchertd5de4dd2010-10-27 15:33:32 -070063 return result;
Matt Helsleydc52ddc2008-10-18 20:27:21 -070064}
65
66/*
67 * cgroups_write_string() limits the size of freezer state strings to
68 * CGROUP_LOCAL_BUFFER_SIZE
69 */
70static const char *freezer_state_strs[] = {
Matt Helsley81dcf332008-10-18 20:27:23 -070071 "THAWED",
Matt Helsleydc52ddc2008-10-18 20:27:21 -070072 "FREEZING",
73 "FROZEN",
74};
75
76/*
77 * State diagram
78 * Transitions are caused by userspace writes to the freezer.state file.
79 * The values in parenthesis are state labels. The rest are edge labels.
80 *
Matt Helsley81dcf332008-10-18 20:27:23 -070081 * (THAWED) --FROZEN--> (FREEZING) --FROZEN--> (FROZEN)
82 * ^ ^ | |
83 * | \_______THAWED_______/ |
84 * \__________________________THAWED____________/
Matt Helsleydc52ddc2008-10-18 20:27:21 -070085 */
86
87struct cgroup_subsys freezer_subsys;
88
89/* Locks taken and their ordering
90 * ------------------------------
Matt Helsleydc52ddc2008-10-18 20:27:21 -070091 * cgroup_mutex (AKA cgroup_lock)
Matt Helsleydc52ddc2008-10-18 20:27:21 -070092 * freezer->lock
Matt Helsley8f775782010-05-10 23:18:47 +020093 * css_set_lock
94 * task->alloc_lock (AKA task_lock)
Matt Helsleydc52ddc2008-10-18 20:27:21 -070095 * task->sighand->siglock
96 *
97 * cgroup code forces css_set_lock to be taken before task->alloc_lock
98 *
99 * freezer_create(), freezer_destroy():
100 * cgroup_mutex [ by cgroup core ]
101 *
Matt Helsley8f775782010-05-10 23:18:47 +0200102 * freezer_can_attach():
103 * cgroup_mutex (held by caller of can_attach)
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700104 *
Matt Helsley8f775782010-05-10 23:18:47 +0200105 * cgroup_freezing_or_frozen():
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700106 * task->alloc_lock (to get task's cgroup)
107 *
108 * freezer_fork() (preserving fork() performance means can't take cgroup_mutex):
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700109 * freezer->lock
110 * sighand->siglock (if the cgroup is freezing)
111 *
112 * freezer_read():
113 * cgroup_mutex
114 * freezer->lock
Matt Helsley8f775782010-05-10 23:18:47 +0200115 * write_lock css_set_lock (cgroup iterator start)
116 * task->alloc_lock
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700117 * read_lock css_set_lock (cgroup iterator start)
118 *
119 * freezer_write() (freeze):
120 * cgroup_mutex
121 * freezer->lock
Matt Helsley8f775782010-05-10 23:18:47 +0200122 * write_lock css_set_lock (cgroup iterator start)
123 * task->alloc_lock
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700124 * read_lock css_set_lock (cgroup iterator start)
Matt Helsley8f775782010-05-10 23:18:47 +0200125 * sighand->siglock (fake signal delivery inside freeze_task())
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700126 *
127 * freezer_write() (unfreeze):
128 * cgroup_mutex
129 * freezer->lock
Matt Helsley8f775782010-05-10 23:18:47 +0200130 * write_lock css_set_lock (cgroup iterator start)
131 * task->alloc_lock
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700132 * read_lock css_set_lock (cgroup iterator start)
Matt Helsley8f775782010-05-10 23:18:47 +0200133 * task->alloc_lock (inside thaw_process(), prevents race with refrigerator())
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700134 * sighand->siglock
135 */
136static struct cgroup_subsys_state *freezer_create(struct cgroup_subsys *ss,
137 struct cgroup *cgroup)
138{
139 struct freezer *freezer;
140
141 freezer = kzalloc(sizeof(struct freezer), GFP_KERNEL);
142 if (!freezer)
143 return ERR_PTR(-ENOMEM);
144
145 spin_lock_init(&freezer->lock);
Matt Helsley81dcf332008-10-18 20:27:23 -0700146 freezer->state = CGROUP_THAWED;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700147 return &freezer->css;
148}
149
150static void freezer_destroy(struct cgroup_subsys *ss,
151 struct cgroup *cgroup)
152{
153 kfree(cgroup_freezer(cgroup));
154}
155
Matt Helsley957a4ee2008-10-18 20:27:22 -0700156/*
157 * The call to cgroup_lock() in the freezer.state write method prevents
158 * a write to that file racing against an attach, and hence the
159 * can_attach() result will remain valid until the attach completes.
160 */
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700161static int freezer_can_attach(struct cgroup_subsys *ss,
162 struct cgroup *new_cgroup,
Ben Blumf780bdb2011-05-26 16:25:19 -0700163 struct task_struct *task)
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700164{
165 struct freezer *freezer;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700166
Li Zefan80a6a2c2008-10-29 14:00:52 -0700167 /*
168 * Anything frozen can't move or be moved to/from.
Li Zefan80a6a2c2008-10-29 14:00:52 -0700169 */
Matt Helsley957a4ee2008-10-18 20:27:22 -0700170
Tomasz Buchert0bdba582010-10-27 15:33:33 -0700171 freezer = cgroup_freezer(new_cgroup);
172 if (freezer->state != CGROUP_THAWED)
Matt Helsley957a4ee2008-10-18 20:27:22 -0700173 return -EBUSY;
174
Ben Blumf780bdb2011-05-26 16:25:19 -0700175 return 0;
176}
177
178static int freezer_can_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
179{
Tomasz Buchert0bdba582010-10-27 15:33:33 -0700180 rcu_read_lock();
Ben Blumf780bdb2011-05-26 16:25:19 -0700181 if (__cgroup_freezing_or_frozen(tsk)) {
Tomasz Buchert0bdba582010-10-27 15:33:33 -0700182 rcu_read_unlock();
Matt Helsley957a4ee2008-10-18 20:27:22 -0700183 return -EBUSY;
Tomasz Buchert0bdba582010-10-27 15:33:33 -0700184 }
185 rcu_read_unlock();
Li Zefan80a6a2c2008-10-29 14:00:52 -0700186 return 0;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700187}
188
189static void freezer_fork(struct cgroup_subsys *ss, struct task_struct *task)
190{
191 struct freezer *freezer;
192
Li Zefan68744672008-11-12 13:26:49 -0800193 /*
194 * No lock is needed, since the task isn't on tasklist yet,
195 * so it can't be moved to another cgroup, which means the
196 * freezer won't be removed and will be valid during this
Paul E. McKenney8b46f882010-04-21 13:02:08 -0700197 * function call. Nevertheless, apply RCU read-side critical
198 * section to suppress RCU lockdep false positives.
Li Zefan68744672008-11-12 13:26:49 -0800199 */
Paul E. McKenney8b46f882010-04-21 13:02:08 -0700200 rcu_read_lock();
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700201 freezer = task_freezer(task);
Paul E. McKenney8b46f882010-04-21 13:02:08 -0700202 rcu_read_unlock();
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700203
Li Zefan3b1b3f62008-11-12 13:26:50 -0800204 /*
205 * The root cgroup is non-freezable, so we can skip the
206 * following check.
207 */
208 if (!freezer->css.cgroup->parent)
209 return;
210
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700211 spin_lock_irq(&freezer->lock);
Li Zefan7ccb9742008-10-29 14:00:51 -0700212 BUG_ON(freezer->state == CGROUP_FROZEN);
213
Matt Helsley81dcf332008-10-18 20:27:23 -0700214 /* Locking avoids race with FREEZING -> THAWED transitions. */
215 if (freezer->state == CGROUP_FREEZING)
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700216 freeze_task(task, true);
217 spin_unlock_irq(&freezer->lock);
218}
219
220/*
221 * caller must hold freezer->lock
222 */
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700223static void update_if_frozen(struct cgroup *cgroup,
Matt Helsley1aece342008-10-18 20:27:24 -0700224 struct freezer *freezer)
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700225{
226 struct cgroup_iter it;
227 struct task_struct *task;
228 unsigned int nfrozen = 0, ntotal = 0;
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700229 enum freezer_state old_state = freezer->state;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700230
231 cgroup_iter_start(cgroup, &it);
232 while ((task = cgroup_iter_next(cgroup, &it))) {
233 ntotal++;
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700234 if (frozen(task))
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700235 nfrozen++;
236 }
237
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700238 if (old_state == CGROUP_THAWED) {
239 BUG_ON(nfrozen > 0);
240 } else if (old_state == CGROUP_FREEZING) {
241 if (nfrozen == ntotal)
242 freezer->state = CGROUP_FROZEN;
243 } else { /* old_state == CGROUP_FROZEN */
244 BUG_ON(nfrozen != ntotal);
245 }
246
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700247 cgroup_iter_end(cgroup, &it);
248}
249
250static int freezer_read(struct cgroup *cgroup, struct cftype *cft,
251 struct seq_file *m)
252{
253 struct freezer *freezer;
254 enum freezer_state state;
255
256 if (!cgroup_lock_live_group(cgroup))
257 return -ENODEV;
258
259 freezer = cgroup_freezer(cgroup);
260 spin_lock_irq(&freezer->lock);
261 state = freezer->state;
Matt Helsley81dcf332008-10-18 20:27:23 -0700262 if (state == CGROUP_FREEZING) {
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700263 /* We change from FREEZING to FROZEN lazily if the cgroup was
264 * only partially frozen when we exitted write. */
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700265 update_if_frozen(cgroup, freezer);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700266 state = freezer->state;
267 }
268 spin_unlock_irq(&freezer->lock);
269 cgroup_unlock();
270
271 seq_puts(m, freezer_state_strs[state]);
272 seq_putc(m, '\n');
273 return 0;
274}
275
276static int try_to_freeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
277{
278 struct cgroup_iter it;
279 struct task_struct *task;
280 unsigned int num_cant_freeze_now = 0;
281
Matt Helsley81dcf332008-10-18 20:27:23 -0700282 freezer->state = CGROUP_FREEZING;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700283 cgroup_iter_start(cgroup, &it);
284 while ((task = cgroup_iter_next(cgroup, &it))) {
285 if (!freeze_task(task, true))
286 continue;
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700287 if (frozen(task))
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700288 continue;
289 if (!freezing(task) && !freezer_should_skip(task))
290 num_cant_freeze_now++;
291 }
292 cgroup_iter_end(cgroup, &it);
293
294 return num_cant_freeze_now ? -EBUSY : 0;
295}
296
Li Zefan00c2e632008-10-29 14:00:53 -0700297static void unfreeze_cgroup(struct cgroup *cgroup, struct freezer *freezer)
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700298{
299 struct cgroup_iter it;
300 struct task_struct *task;
301
302 cgroup_iter_start(cgroup, &it);
303 while ((task = cgroup_iter_next(cgroup, &it))) {
Li Zefan00c2e632008-10-29 14:00:53 -0700304 thaw_process(task);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700305 }
306 cgroup_iter_end(cgroup, &it);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700307
Li Zefan00c2e632008-10-29 14:00:53 -0700308 freezer->state = CGROUP_THAWED;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700309}
310
311static int freezer_change_state(struct cgroup *cgroup,
312 enum freezer_state goal_state)
313{
314 struct freezer *freezer;
315 int retval = 0;
316
317 freezer = cgroup_freezer(cgroup);
Li Zefan51308ee2008-10-29 14:00:54 -0700318
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700319 spin_lock_irq(&freezer->lock);
Li Zefan51308ee2008-10-29 14:00:54 -0700320
Tomasz Buchert2d3cbf82010-10-27 15:33:34 -0700321 update_if_frozen(cgroup, freezer);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700322 if (goal_state == freezer->state)
323 goto out;
Li Zefan51308ee2008-10-29 14:00:54 -0700324
325 switch (goal_state) {
Matt Helsley81dcf332008-10-18 20:27:23 -0700326 case CGROUP_THAWED:
Li Zefan00c2e632008-10-29 14:00:53 -0700327 unfreeze_cgroup(cgroup, freezer);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700328 break;
Li Zefan51308ee2008-10-29 14:00:54 -0700329 case CGROUP_FROZEN:
330 retval = try_to_freeze_cgroup(cgroup, freezer);
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700331 break;
Li Zefan51308ee2008-10-29 14:00:54 -0700332 default:
333 BUG();
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700334 }
335out:
336 spin_unlock_irq(&freezer->lock);
337
338 return retval;
339}
340
341static int freezer_write(struct cgroup *cgroup,
342 struct cftype *cft,
343 const char *buffer)
344{
345 int retval;
346 enum freezer_state goal_state;
347
Matt Helsley81dcf332008-10-18 20:27:23 -0700348 if (strcmp(buffer, freezer_state_strs[CGROUP_THAWED]) == 0)
349 goal_state = CGROUP_THAWED;
350 else if (strcmp(buffer, freezer_state_strs[CGROUP_FROZEN]) == 0)
351 goal_state = CGROUP_FROZEN;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700352 else
Li Zefan3b1b3f62008-11-12 13:26:50 -0800353 return -EINVAL;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700354
355 if (!cgroup_lock_live_group(cgroup))
356 return -ENODEV;
357 retval = freezer_change_state(cgroup, goal_state);
358 cgroup_unlock();
359 return retval;
360}
361
362static struct cftype files[] = {
363 {
364 .name = "state",
365 .read_seq_string = freezer_read,
366 .write_string = freezer_write,
367 },
368};
369
370static int freezer_populate(struct cgroup_subsys *ss, struct cgroup *cgroup)
371{
Li Zefan3b1b3f62008-11-12 13:26:50 -0800372 if (!cgroup->parent)
373 return 0;
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700374 return cgroup_add_files(cgroup, ss, files, ARRAY_SIZE(files));
375}
376
377struct cgroup_subsys freezer_subsys = {
378 .name = "freezer",
379 .create = freezer_create,
380 .destroy = freezer_destroy,
381 .populate = freezer_populate,
382 .subsys_id = freezer_subsys_id,
383 .can_attach = freezer_can_attach,
Ben Blumf780bdb2011-05-26 16:25:19 -0700384 .can_attach_task = freezer_can_attach_task,
385 .pre_attach = NULL,
386 .attach_task = NULL,
Matt Helsleydc52ddc2008-10-18 20:27:21 -0700387 .attach = NULL,
388 .fork = freezer_fork,
389 .exit = NULL,
390};