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