]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - kernel/cgroup.c
x86, UV: cpu_relax in uv_wait_completion
[mirror_ubuntu-bionic-kernel.git] / kernel / cgroup.c
CommitLineData
ddbcc7e8 1/*
ddbcc7e8
PM
2 * Generic process-grouping system.
3 *
4 * Based originally on the cpuset system, extracted by Paul Menage
5 * Copyright (C) 2006 Google, Inc
6 *
7 * Copyright notices from the original cpuset code:
8 * --------------------------------------------------
9 * Copyright (C) 2003 BULL SA.
10 * Copyright (C) 2004-2006 Silicon Graphics, Inc.
11 *
12 * Portions derived from Patrick Mochel's sysfs code.
13 * sysfs is Copyright (c) 2001-3 Patrick Mochel
14 *
15 * 2003-10-10 Written by Simon Derr.
16 * 2003-10-22 Updates by Stephen Hemminger.
17 * 2004 May-July Rework by Paul Jackson.
18 * ---------------------------------------------------
19 *
20 * This file is subject to the terms and conditions of the GNU General Public
21 * License. See the file COPYING in the main directory of the Linux
22 * distribution for more details.
23 */
24
25#include <linux/cgroup.h>
26#include <linux/errno.h>
27#include <linux/fs.h>
28#include <linux/kernel.h>
29#include <linux/list.h>
30#include <linux/mm.h>
31#include <linux/mutex.h>
32#include <linux/mount.h>
33#include <linux/pagemap.h>
a424316c 34#include <linux/proc_fs.h>
ddbcc7e8
PM
35#include <linux/rcupdate.h>
36#include <linux/sched.h>
817929ec 37#include <linux/backing-dev.h>
ddbcc7e8
PM
38#include <linux/seq_file.h>
39#include <linux/slab.h>
40#include <linux/magic.h>
41#include <linux/spinlock.h>
42#include <linux/string.h>
bbcb81d0 43#include <linux/sort.h>
81a6a5cd 44#include <linux/kmod.h>
846c7bb0
BS
45#include <linux/delayacct.h>
46#include <linux/cgroupstats.h>
472b1053 47#include <linux/hash.h>
3f8206d4 48#include <linux/namei.h>
846c7bb0 49
ddbcc7e8
PM
50#include <asm/atomic.h>
51
81a6a5cd
PM
52static DEFINE_MUTEX(cgroup_mutex);
53
ddbcc7e8
PM
54/* Generate an array of cgroup subsystem pointers */
55#define SUBSYS(_x) &_x ## _subsys,
56
57static struct cgroup_subsys *subsys[] = {
58#include <linux/cgroup_subsys.h>
59};
60
61/*
62 * A cgroupfs_root represents the root of a cgroup hierarchy,
63 * and may be associated with a superblock to form an active
64 * hierarchy
65 */
66struct cgroupfs_root {
67 struct super_block *sb;
68
69 /*
70 * The bitmask of subsystems intended to be attached to this
71 * hierarchy
72 */
73 unsigned long subsys_bits;
74
75 /* The bitmask of subsystems currently attached to this hierarchy */
76 unsigned long actual_subsys_bits;
77
78 /* A list running through the attached subsystems */
79 struct list_head subsys_list;
80
81 /* The root cgroup for this hierarchy */
82 struct cgroup top_cgroup;
83
84 /* Tracks how many cgroups are currently defined in hierarchy.*/
85 int number_of_cgroups;
86
e5f6a860 87 /* A list running through the active hierarchies */
ddbcc7e8
PM
88 struct list_head root_list;
89
90 /* Hierarchy-specific flags */
91 unsigned long flags;
81a6a5cd 92
e788e066 93 /* The path to use for release notifications. */
81a6a5cd 94 char release_agent_path[PATH_MAX];
ddbcc7e8
PM
95};
96
97
98/*
99 * The "rootnode" hierarchy is the "dummy hierarchy", reserved for the
100 * subsystems that are otherwise unattached - it never has more than a
101 * single cgroup, and all tasks are part of that cgroup.
102 */
103static struct cgroupfs_root rootnode;
104
105/* The list of hierarchy roots */
106
107static LIST_HEAD(roots);
817929ec 108static int root_count;
ddbcc7e8
PM
109
110/* dummytop is a shorthand for the dummy hierarchy's top cgroup */
111#define dummytop (&rootnode.top_cgroup)
112
113/* This flag indicates whether tasks in the fork and exit paths should
a043e3b2
LZ
114 * check for fork/exit handlers to call. This avoids us having to do
115 * extra work in the fork/exit path if none of the subsystems need to
116 * be called.
ddbcc7e8 117 */
8947f9d5 118static int need_forkexit_callback __read_mostly;
ddbcc7e8 119
ddbcc7e8 120/* convenient tests for these bits */
bd89aabc 121inline int cgroup_is_removed(const struct cgroup *cgrp)
ddbcc7e8 122{
bd89aabc 123 return test_bit(CGRP_REMOVED, &cgrp->flags);
ddbcc7e8
PM
124}
125
126/* bits in struct cgroupfs_root flags field */
127enum {
128 ROOT_NOPREFIX, /* mounted subsystems have no named prefix */
129};
130
e9685a03 131static int cgroup_is_releasable(const struct cgroup *cgrp)
81a6a5cd
PM
132{
133 const int bits =
bd89aabc
PM
134 (1 << CGRP_RELEASABLE) |
135 (1 << CGRP_NOTIFY_ON_RELEASE);
136 return (cgrp->flags & bits) == bits;
81a6a5cd
PM
137}
138
e9685a03 139static int notify_on_release(const struct cgroup *cgrp)
81a6a5cd 140{
bd89aabc 141 return test_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
81a6a5cd
PM
142}
143
ddbcc7e8
PM
144/*
145 * for_each_subsys() allows you to iterate on each subsystem attached to
146 * an active hierarchy
147 */
148#define for_each_subsys(_root, _ss) \
149list_for_each_entry(_ss, &_root->subsys_list, sibling)
150
e5f6a860
LZ
151/* for_each_active_root() allows you to iterate across the active hierarchies */
152#define for_each_active_root(_root) \
ddbcc7e8
PM
153list_for_each_entry(_root, &roots, root_list)
154
81a6a5cd
PM
155/* the list of cgroups eligible for automatic release. Protected by
156 * release_list_lock */
157static LIST_HEAD(release_list);
158static DEFINE_SPINLOCK(release_list_lock);
159static void cgroup_release_agent(struct work_struct *work);
160static DECLARE_WORK(release_agent_work, cgroup_release_agent);
bd89aabc 161static void check_for_release(struct cgroup *cgrp);
81a6a5cd 162
817929ec
PM
163/* Link structure for associating css_set objects with cgroups */
164struct cg_cgroup_link {
165 /*
166 * List running through cg_cgroup_links associated with a
167 * cgroup, anchored on cgroup->css_sets
168 */
bd89aabc 169 struct list_head cgrp_link_list;
817929ec
PM
170 /*
171 * List running through cg_cgroup_links pointing at a
172 * single css_set object, anchored on css_set->cg_links
173 */
174 struct list_head cg_link_list;
175 struct css_set *cg;
176};
177
178/* The default css_set - used by init and its children prior to any
179 * hierarchies being mounted. It contains a pointer to the root state
180 * for each subsystem. Also used to anchor the list of css_sets. Not
181 * reference-counted, to improve performance when child cgroups
182 * haven't been created.
183 */
184
185static struct css_set init_css_set;
186static struct cg_cgroup_link init_css_set_link;
187
188/* css_set_lock protects the list of css_set objects, and the
189 * chain of tasks off each css_set. Nests outside task->alloc_lock
190 * due to cgroup_iter_start() */
191static DEFINE_RWLOCK(css_set_lock);
192static int css_set_count;
193
472b1053
LZ
194/* hash table for cgroup groups. This improves the performance to
195 * find an existing css_set */
196#define CSS_SET_HASH_BITS 7
197#define CSS_SET_TABLE_SIZE (1 << CSS_SET_HASH_BITS)
198static struct hlist_head css_set_table[CSS_SET_TABLE_SIZE];
199
200static struct hlist_head *css_set_hash(struct cgroup_subsys_state *css[])
201{
202 int i;
203 int index;
204 unsigned long tmp = 0UL;
205
206 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++)
207 tmp += (unsigned long)css[i];
208 tmp = (tmp >> 16) ^ tmp;
209
210 index = hash_long(tmp, CSS_SET_HASH_BITS);
211
212 return &css_set_table[index];
213}
214
817929ec
PM
215/* We don't maintain the lists running through each css_set to its
216 * task until after the first call to cgroup_iter_start(). This
217 * reduces the fork()/exit() overhead for people who have cgroups
218 * compiled into their kernel but not actually in use */
8947f9d5 219static int use_task_css_set_links __read_mostly;
817929ec
PM
220
221/* When we create or destroy a css_set, the operation simply
222 * takes/releases a reference count on all the cgroups referenced
223 * by subsystems in this css_set. This can end up multiple-counting
224 * some cgroups, but that's OK - the ref-count is just a
225 * busy/not-busy indicator; ensuring that we only count each cgroup
226 * once would require taking a global lock to ensure that no
b4f48b63
PM
227 * subsystems moved between hierarchies while we were doing so.
228 *
229 * Possible TODO: decide at boot time based on the number of
230 * registered subsystems and the number of CPUs or NUMA nodes whether
231 * it's better for performance to ref-count every subsystem, or to
232 * take a global lock and only add one ref count to each hierarchy.
233 */
817929ec
PM
234
235/*
236 * unlink a css_set from the list and free it
237 */
81a6a5cd 238static void unlink_css_set(struct css_set *cg)
b4f48b63 239{
71cbb949
KM
240 struct cg_cgroup_link *link;
241 struct cg_cgroup_link *saved_link;
242
472b1053 243 hlist_del(&cg->hlist);
817929ec 244 css_set_count--;
71cbb949
KM
245
246 list_for_each_entry_safe(link, saved_link, &cg->cg_links,
247 cg_link_list) {
817929ec 248 list_del(&link->cg_link_list);
bd89aabc 249 list_del(&link->cgrp_link_list);
817929ec
PM
250 kfree(link);
251 }
81a6a5cd
PM
252}
253
146aa1bd 254static void __put_css_set(struct css_set *cg, int taskexit)
81a6a5cd
PM
255{
256 int i;
146aa1bd
LJ
257 /*
258 * Ensure that the refcount doesn't hit zero while any readers
259 * can see it. Similar to atomic_dec_and_lock(), but for an
260 * rwlock
261 */
262 if (atomic_add_unless(&cg->refcount, -1, 1))
263 return;
264 write_lock(&css_set_lock);
265 if (!atomic_dec_and_test(&cg->refcount)) {
266 write_unlock(&css_set_lock);
267 return;
268 }
81a6a5cd 269 unlink_css_set(cg);
146aa1bd 270 write_unlock(&css_set_lock);
81a6a5cd
PM
271
272 rcu_read_lock();
273 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
a47295e6 274 struct cgroup *cgrp = rcu_dereference(cg->subsys[i]->cgroup);
bd89aabc
PM
275 if (atomic_dec_and_test(&cgrp->count) &&
276 notify_on_release(cgrp)) {
81a6a5cd 277 if (taskexit)
bd89aabc
PM
278 set_bit(CGRP_RELEASABLE, &cgrp->flags);
279 check_for_release(cgrp);
81a6a5cd
PM
280 }
281 }
282 rcu_read_unlock();
817929ec 283 kfree(cg);
b4f48b63
PM
284}
285
817929ec
PM
286/*
287 * refcounted get/put for css_set objects
288 */
289static inline void get_css_set(struct css_set *cg)
290{
146aa1bd 291 atomic_inc(&cg->refcount);
817929ec
PM
292}
293
294static inline void put_css_set(struct css_set *cg)
295{
146aa1bd 296 __put_css_set(cg, 0);
817929ec
PM
297}
298
81a6a5cd
PM
299static inline void put_css_set_taskexit(struct css_set *cg)
300{
146aa1bd 301 __put_css_set(cg, 1);
81a6a5cd
PM
302}
303
817929ec
PM
304/*
305 * find_existing_css_set() is a helper for
306 * find_css_set(), and checks to see whether an existing
472b1053 307 * css_set is suitable.
817929ec
PM
308 *
309 * oldcg: the cgroup group that we're using before the cgroup
310 * transition
311 *
bd89aabc 312 * cgrp: the cgroup that we're moving into
817929ec
PM
313 *
314 * template: location in which to build the desired set of subsystem
315 * state objects for the new cgroup group
316 */
817929ec
PM
317static struct css_set *find_existing_css_set(
318 struct css_set *oldcg,
bd89aabc 319 struct cgroup *cgrp,
817929ec 320 struct cgroup_subsys_state *template[])
b4f48b63
PM
321{
322 int i;
bd89aabc 323 struct cgroupfs_root *root = cgrp->root;
472b1053
LZ
324 struct hlist_head *hhead;
325 struct hlist_node *node;
326 struct css_set *cg;
817929ec
PM
327
328 /* Built the set of subsystem state objects that we want to
329 * see in the new css_set */
330 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
8d53d55d 331 if (root->subsys_bits & (1UL << i)) {
817929ec
PM
332 /* Subsystem is in this hierarchy. So we want
333 * the subsystem state from the new
334 * cgroup */
bd89aabc 335 template[i] = cgrp->subsys[i];
817929ec
PM
336 } else {
337 /* Subsystem is not in this hierarchy, so we
338 * don't want to change the subsystem state */
339 template[i] = oldcg->subsys[i];
340 }
341 }
342
472b1053
LZ
343 hhead = css_set_hash(template);
344 hlist_for_each_entry(cg, node, hhead, hlist) {
817929ec
PM
345 if (!memcmp(template, cg->subsys, sizeof(cg->subsys))) {
346 /* All subsystems matched */
347 return cg;
348 }
472b1053 349 }
817929ec
PM
350
351 /* No existing cgroup group matched */
352 return NULL;
353}
354
36553434
LZ
355static void free_cg_links(struct list_head *tmp)
356{
357 struct cg_cgroup_link *link;
358 struct cg_cgroup_link *saved_link;
359
360 list_for_each_entry_safe(link, saved_link, tmp, cgrp_link_list) {
361 list_del(&link->cgrp_link_list);
362 kfree(link);
363 }
364}
365
817929ec
PM
366/*
367 * allocate_cg_links() allocates "count" cg_cgroup_link structures
bd89aabc 368 * and chains them on tmp through their cgrp_link_list fields. Returns 0 on
817929ec
PM
369 * success or a negative error
370 */
817929ec
PM
371static int allocate_cg_links(int count, struct list_head *tmp)
372{
373 struct cg_cgroup_link *link;
374 int i;
375 INIT_LIST_HEAD(tmp);
376 for (i = 0; i < count; i++) {
377 link = kmalloc(sizeof(*link), GFP_KERNEL);
378 if (!link) {
36553434 379 free_cg_links(tmp);
817929ec
PM
380 return -ENOMEM;
381 }
bd89aabc 382 list_add(&link->cgrp_link_list, tmp);
817929ec
PM
383 }
384 return 0;
385}
386
c12f65d4
LZ
387/**
388 * link_css_set - a helper function to link a css_set to a cgroup
389 * @tmp_cg_links: cg_cgroup_link objects allocated by allocate_cg_links()
390 * @cg: the css_set to be linked
391 * @cgrp: the destination cgroup
392 */
393static void link_css_set(struct list_head *tmp_cg_links,
394 struct css_set *cg, struct cgroup *cgrp)
395{
396 struct cg_cgroup_link *link;
397
398 BUG_ON(list_empty(tmp_cg_links));
399 link = list_first_entry(tmp_cg_links, struct cg_cgroup_link,
400 cgrp_link_list);
401 link->cg = cg;
402 list_move(&link->cgrp_link_list, &cgrp->css_sets);
403 list_add(&link->cg_link_list, &cg->cg_links);
404}
405
817929ec
PM
406/*
407 * find_css_set() takes an existing cgroup group and a
408 * cgroup object, and returns a css_set object that's
409 * equivalent to the old group, but with the given cgroup
410 * substituted into the appropriate hierarchy. Must be called with
411 * cgroup_mutex held
412 */
817929ec 413static struct css_set *find_css_set(
bd89aabc 414 struct css_set *oldcg, struct cgroup *cgrp)
817929ec
PM
415{
416 struct css_set *res;
417 struct cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT];
418 int i;
419
420 struct list_head tmp_cg_links;
817929ec 421
472b1053
LZ
422 struct hlist_head *hhead;
423
817929ec
PM
424 /* First see if we already have a cgroup group that matches
425 * the desired set */
7e9abd89 426 read_lock(&css_set_lock);
bd89aabc 427 res = find_existing_css_set(oldcg, cgrp, template);
817929ec
PM
428 if (res)
429 get_css_set(res);
7e9abd89 430 read_unlock(&css_set_lock);
817929ec
PM
431
432 if (res)
433 return res;
434
435 res = kmalloc(sizeof(*res), GFP_KERNEL);
436 if (!res)
437 return NULL;
438
439 /* Allocate all the cg_cgroup_link objects that we'll need */
440 if (allocate_cg_links(root_count, &tmp_cg_links) < 0) {
441 kfree(res);
442 return NULL;
443 }
444
146aa1bd 445 atomic_set(&res->refcount, 1);
817929ec
PM
446 INIT_LIST_HEAD(&res->cg_links);
447 INIT_LIST_HEAD(&res->tasks);
472b1053 448 INIT_HLIST_NODE(&res->hlist);
817929ec
PM
449
450 /* Copy the set of subsystem state objects generated in
451 * find_existing_css_set() */
452 memcpy(res->subsys, template, sizeof(res->subsys));
453
454 write_lock(&css_set_lock);
455 /* Add reference counts and links from the new css_set. */
456 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
bd89aabc 457 struct cgroup *cgrp = res->subsys[i]->cgroup;
817929ec 458 struct cgroup_subsys *ss = subsys[i];
bd89aabc 459 atomic_inc(&cgrp->count);
817929ec
PM
460 /*
461 * We want to add a link once per cgroup, so we
462 * only do it for the first subsystem in each
463 * hierarchy
464 */
c12f65d4
LZ
465 if (ss->root->subsys_list.next == &ss->sibling)
466 link_css_set(&tmp_cg_links, res, cgrp);
817929ec 467 }
c12f65d4
LZ
468 if (list_empty(&rootnode.subsys_list))
469 link_css_set(&tmp_cg_links, res, dummytop);
817929ec
PM
470
471 BUG_ON(!list_empty(&tmp_cg_links));
472
817929ec 473 css_set_count++;
472b1053
LZ
474
475 /* Add this cgroup group to the hash table */
476 hhead = css_set_hash(res->subsys);
477 hlist_add_head(&res->hlist, hhead);
478
817929ec
PM
479 write_unlock(&css_set_lock);
480
481 return res;
b4f48b63
PM
482}
483
ddbcc7e8
PM
484/*
485 * There is one global cgroup mutex. We also require taking
486 * task_lock() when dereferencing a task's cgroup subsys pointers.
487 * See "The task_lock() exception", at the end of this comment.
488 *
489 * A task must hold cgroup_mutex to modify cgroups.
490 *
491 * Any task can increment and decrement the count field without lock.
492 * So in general, code holding cgroup_mutex can't rely on the count
493 * field not changing. However, if the count goes to zero, then only
956db3ca 494 * cgroup_attach_task() can increment it again. Because a count of zero
ddbcc7e8
PM
495 * means that no tasks are currently attached, therefore there is no
496 * way a task attached to that cgroup can fork (the other way to
497 * increment the count). So code holding cgroup_mutex can safely
498 * assume that if the count is zero, it will stay zero. Similarly, if
499 * a task holds cgroup_mutex on a cgroup with zero count, it
500 * knows that the cgroup won't be removed, as cgroup_rmdir()
501 * needs that mutex.
502 *
ddbcc7e8
PM
503 * The fork and exit callbacks cgroup_fork() and cgroup_exit(), don't
504 * (usually) take cgroup_mutex. These are the two most performance
505 * critical pieces of code here. The exception occurs on cgroup_exit(),
506 * when a task in a notify_on_release cgroup exits. Then cgroup_mutex
507 * is taken, and if the cgroup count is zero, a usermode call made
a043e3b2
LZ
508 * to the release agent with the name of the cgroup (path relative to
509 * the root of cgroup file system) as the argument.
ddbcc7e8
PM
510 *
511 * A cgroup can only be deleted if both its 'count' of using tasks
512 * is zero, and its list of 'children' cgroups is empty. Since all
513 * tasks in the system use _some_ cgroup, and since there is always at
514 * least one task in the system (init, pid == 1), therefore, top_cgroup
515 * always has either children cgroups and/or using tasks. So we don't
516 * need a special hack to ensure that top_cgroup cannot be deleted.
517 *
518 * The task_lock() exception
519 *
520 * The need for this exception arises from the action of
956db3ca 521 * cgroup_attach_task(), which overwrites one tasks cgroup pointer with
a043e3b2 522 * another. It does so using cgroup_mutex, however there are
ddbcc7e8
PM
523 * several performance critical places that need to reference
524 * task->cgroup without the expense of grabbing a system global
525 * mutex. Therefore except as noted below, when dereferencing or, as
956db3ca 526 * in cgroup_attach_task(), modifying a task'ss cgroup pointer we use
ddbcc7e8
PM
527 * task_lock(), which acts on a spinlock (task->alloc_lock) already in
528 * the task_struct routinely used for such matters.
529 *
530 * P.S. One more locking exception. RCU is used to guard the
956db3ca 531 * update of a tasks cgroup pointer by cgroup_attach_task()
ddbcc7e8
PM
532 */
533
ddbcc7e8
PM
534/**
535 * cgroup_lock - lock out any changes to cgroup structures
536 *
537 */
ddbcc7e8
PM
538void cgroup_lock(void)
539{
540 mutex_lock(&cgroup_mutex);
541}
542
543/**
544 * cgroup_unlock - release lock on cgroup changes
545 *
546 * Undo the lock taken in a previous cgroup_lock() call.
547 */
ddbcc7e8
PM
548void cgroup_unlock(void)
549{
550 mutex_unlock(&cgroup_mutex);
551}
552
553/*
554 * A couple of forward declarations required, due to cyclic reference loop:
555 * cgroup_mkdir -> cgroup_create -> cgroup_populate_dir ->
556 * cgroup_add_file -> cgroup_create_file -> cgroup_dir_inode_operations
557 * -> cgroup_mkdir.
558 */
559
560static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode);
561static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry);
bd89aabc 562static int cgroup_populate_dir(struct cgroup *cgrp);
ddbcc7e8 563static struct inode_operations cgroup_dir_inode_operations;
a424316c
PM
564static struct file_operations proc_cgroupstats_operations;
565
566static struct backing_dev_info cgroup_backing_dev_info = {
e4ad08fe 567 .capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
a424316c 568};
ddbcc7e8
PM
569
570static struct inode *cgroup_new_inode(mode_t mode, struct super_block *sb)
571{
572 struct inode *inode = new_inode(sb);
ddbcc7e8
PM
573
574 if (inode) {
575 inode->i_mode = mode;
76aac0e9
DH
576 inode->i_uid = current_fsuid();
577 inode->i_gid = current_fsgid();
ddbcc7e8
PM
578 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
579 inode->i_mapping->backing_dev_info = &cgroup_backing_dev_info;
580 }
581 return inode;
582}
583
4fca88c8
KH
584/*
585 * Call subsys's pre_destroy handler.
586 * This is called before css refcnt check.
587 */
4fca88c8
KH
588static void cgroup_call_pre_destroy(struct cgroup *cgrp)
589{
590 struct cgroup_subsys *ss;
591 for_each_subsys(cgrp->root, ss)
75139b82 592 if (ss->pre_destroy)
4fca88c8
KH
593 ss->pre_destroy(ss, cgrp);
594 return;
595}
596
a47295e6
PM
597static void free_cgroup_rcu(struct rcu_head *obj)
598{
599 struct cgroup *cgrp = container_of(obj, struct cgroup, rcu_head);
600
601 kfree(cgrp);
602}
603
ddbcc7e8
PM
604static void cgroup_diput(struct dentry *dentry, struct inode *inode)
605{
606 /* is dentry a directory ? if so, kfree() associated cgroup */
607 if (S_ISDIR(inode->i_mode)) {
bd89aabc 608 struct cgroup *cgrp = dentry->d_fsdata;
8dc4f3e1 609 struct cgroup_subsys *ss;
bd89aabc 610 BUG_ON(!(cgroup_is_removed(cgrp)));
81a6a5cd
PM
611 /* It's possible for external users to be holding css
612 * reference counts on a cgroup; css_put() needs to
613 * be able to access the cgroup after decrementing
614 * the reference count in order to know if it needs to
615 * queue the cgroup to be handled by the release
616 * agent */
617 synchronize_rcu();
8dc4f3e1
PM
618
619 mutex_lock(&cgroup_mutex);
620 /*
621 * Release the subsystem state objects.
622 */
75139b82
LZ
623 for_each_subsys(cgrp->root, ss)
624 ss->destroy(ss, cgrp);
8dc4f3e1
PM
625
626 cgrp->root->number_of_cgroups--;
627 mutex_unlock(&cgroup_mutex);
628
a47295e6
PM
629 /*
630 * Drop the active superblock reference that we took when we
631 * created the cgroup
632 */
8dc4f3e1
PM
633 deactivate_super(cgrp->root->sb);
634
a47295e6 635 call_rcu(&cgrp->rcu_head, free_cgroup_rcu);
ddbcc7e8
PM
636 }
637 iput(inode);
638}
639
640static void remove_dir(struct dentry *d)
641{
642 struct dentry *parent = dget(d->d_parent);
643
644 d_delete(d);
645 simple_rmdir(parent->d_inode, d);
646 dput(parent);
647}
648
649static void cgroup_clear_directory(struct dentry *dentry)
650{
651 struct list_head *node;
652
653 BUG_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
654 spin_lock(&dcache_lock);
655 node = dentry->d_subdirs.next;
656 while (node != &dentry->d_subdirs) {
657 struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
658 list_del_init(node);
659 if (d->d_inode) {
660 /* This should never be called on a cgroup
661 * directory with child cgroups */
662 BUG_ON(d->d_inode->i_mode & S_IFDIR);
663 d = dget_locked(d);
664 spin_unlock(&dcache_lock);
665 d_delete(d);
666 simple_unlink(dentry->d_inode, d);
667 dput(d);
668 spin_lock(&dcache_lock);
669 }
670 node = dentry->d_subdirs.next;
671 }
672 spin_unlock(&dcache_lock);
673}
674
675/*
676 * NOTE : the dentry must have been dget()'ed
677 */
678static void cgroup_d_remove_dir(struct dentry *dentry)
679{
680 cgroup_clear_directory(dentry);
681
682 spin_lock(&dcache_lock);
683 list_del_init(&dentry->d_u.d_child);
684 spin_unlock(&dcache_lock);
685 remove_dir(dentry);
686}
687
688static int rebind_subsystems(struct cgroupfs_root *root,
689 unsigned long final_bits)
690{
691 unsigned long added_bits, removed_bits;
bd89aabc 692 struct cgroup *cgrp = &root->top_cgroup;
ddbcc7e8
PM
693 int i;
694
695 removed_bits = root->actual_subsys_bits & ~final_bits;
696 added_bits = final_bits & ~root->actual_subsys_bits;
697 /* Check that any added subsystems are currently free */
698 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
8d53d55d 699 unsigned long bit = 1UL << i;
ddbcc7e8
PM
700 struct cgroup_subsys *ss = subsys[i];
701 if (!(bit & added_bits))
702 continue;
703 if (ss->root != &rootnode) {
704 /* Subsystem isn't free */
705 return -EBUSY;
706 }
707 }
708
709 /* Currently we don't handle adding/removing subsystems when
710 * any child cgroups exist. This is theoretically supportable
711 * but involves complex error handling, so it's being left until
712 * later */
307257cf 713 if (root->number_of_cgroups > 1)
ddbcc7e8
PM
714 return -EBUSY;
715
716 /* Process each subsystem */
717 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
718 struct cgroup_subsys *ss = subsys[i];
719 unsigned long bit = 1UL << i;
720 if (bit & added_bits) {
721 /* We're binding this subsystem to this hierarchy */
bd89aabc 722 BUG_ON(cgrp->subsys[i]);
ddbcc7e8
PM
723 BUG_ON(!dummytop->subsys[i]);
724 BUG_ON(dummytop->subsys[i]->cgroup != dummytop);
999cd8a4 725 mutex_lock(&ss->hierarchy_mutex);
bd89aabc
PM
726 cgrp->subsys[i] = dummytop->subsys[i];
727 cgrp->subsys[i]->cgroup = cgrp;
33a68ac1 728 list_move(&ss->sibling, &root->subsys_list);
b2aa30f7 729 ss->root = root;
ddbcc7e8 730 if (ss->bind)
bd89aabc 731 ss->bind(ss, cgrp);
999cd8a4 732 mutex_unlock(&ss->hierarchy_mutex);
ddbcc7e8
PM
733 } else if (bit & removed_bits) {
734 /* We're removing this subsystem */
bd89aabc
PM
735 BUG_ON(cgrp->subsys[i] != dummytop->subsys[i]);
736 BUG_ON(cgrp->subsys[i]->cgroup != cgrp);
999cd8a4 737 mutex_lock(&ss->hierarchy_mutex);
ddbcc7e8
PM
738 if (ss->bind)
739 ss->bind(ss, dummytop);
740 dummytop->subsys[i]->cgroup = dummytop;
bd89aabc 741 cgrp->subsys[i] = NULL;
b2aa30f7 742 subsys[i]->root = &rootnode;
33a68ac1 743 list_move(&ss->sibling, &rootnode.subsys_list);
999cd8a4 744 mutex_unlock(&ss->hierarchy_mutex);
ddbcc7e8
PM
745 } else if (bit & final_bits) {
746 /* Subsystem state should already exist */
bd89aabc 747 BUG_ON(!cgrp->subsys[i]);
ddbcc7e8
PM
748 } else {
749 /* Subsystem state shouldn't exist */
bd89aabc 750 BUG_ON(cgrp->subsys[i]);
ddbcc7e8
PM
751 }
752 }
753 root->subsys_bits = root->actual_subsys_bits = final_bits;
754 synchronize_rcu();
755
756 return 0;
757}
758
759static int cgroup_show_options(struct seq_file *seq, struct vfsmount *vfs)
760{
761 struct cgroupfs_root *root = vfs->mnt_sb->s_fs_info;
762 struct cgroup_subsys *ss;
763
764 mutex_lock(&cgroup_mutex);
765 for_each_subsys(root, ss)
766 seq_printf(seq, ",%s", ss->name);
767 if (test_bit(ROOT_NOPREFIX, &root->flags))
768 seq_puts(seq, ",noprefix");
81a6a5cd
PM
769 if (strlen(root->release_agent_path))
770 seq_printf(seq, ",release_agent=%s", root->release_agent_path);
ddbcc7e8
PM
771 mutex_unlock(&cgroup_mutex);
772 return 0;
773}
774
775struct cgroup_sb_opts {
776 unsigned long subsys_bits;
777 unsigned long flags;
81a6a5cd 778 char *release_agent;
ddbcc7e8
PM
779};
780
781/* Convert a hierarchy specifier into a bitmask of subsystems and
782 * flags. */
783static int parse_cgroupfs_options(char *data,
784 struct cgroup_sb_opts *opts)
785{
786 char *token, *o = data ?: "all";
787
788 opts->subsys_bits = 0;
789 opts->flags = 0;
81a6a5cd 790 opts->release_agent = NULL;
ddbcc7e8
PM
791
792 while ((token = strsep(&o, ",")) != NULL) {
793 if (!*token)
794 return -EINVAL;
795 if (!strcmp(token, "all")) {
8bab8dde
PM
796 /* Add all non-disabled subsystems */
797 int i;
798 opts->subsys_bits = 0;
799 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
800 struct cgroup_subsys *ss = subsys[i];
801 if (!ss->disabled)
802 opts->subsys_bits |= 1ul << i;
803 }
ddbcc7e8
PM
804 } else if (!strcmp(token, "noprefix")) {
805 set_bit(ROOT_NOPREFIX, &opts->flags);
81a6a5cd
PM
806 } else if (!strncmp(token, "release_agent=", 14)) {
807 /* Specifying two release agents is forbidden */
808 if (opts->release_agent)
809 return -EINVAL;
810 opts->release_agent = kzalloc(PATH_MAX, GFP_KERNEL);
811 if (!opts->release_agent)
812 return -ENOMEM;
813 strncpy(opts->release_agent, token + 14, PATH_MAX - 1);
814 opts->release_agent[PATH_MAX - 1] = 0;
ddbcc7e8
PM
815 } else {
816 struct cgroup_subsys *ss;
817 int i;
818 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
819 ss = subsys[i];
820 if (!strcmp(token, ss->name)) {
8bab8dde
PM
821 if (!ss->disabled)
822 set_bit(i, &opts->subsys_bits);
ddbcc7e8
PM
823 break;
824 }
825 }
826 if (i == CGROUP_SUBSYS_COUNT)
827 return -ENOENT;
828 }
829 }
830
831 /* We can't have an empty hierarchy */
832 if (!opts->subsys_bits)
833 return -EINVAL;
834
835 return 0;
836}
837
838static int cgroup_remount(struct super_block *sb, int *flags, char *data)
839{
840 int ret = 0;
841 struct cgroupfs_root *root = sb->s_fs_info;
bd89aabc 842 struct cgroup *cgrp = &root->top_cgroup;
ddbcc7e8
PM
843 struct cgroup_sb_opts opts;
844
bd89aabc 845 mutex_lock(&cgrp->dentry->d_inode->i_mutex);
ddbcc7e8
PM
846 mutex_lock(&cgroup_mutex);
847
848 /* See what subsystems are wanted */
849 ret = parse_cgroupfs_options(data, &opts);
850 if (ret)
851 goto out_unlock;
852
853 /* Don't allow flags to change at remount */
854 if (opts.flags != root->flags) {
855 ret = -EINVAL;
856 goto out_unlock;
857 }
858
859 ret = rebind_subsystems(root, opts.subsys_bits);
860
861 /* (re)populate subsystem files */
862 if (!ret)
bd89aabc 863 cgroup_populate_dir(cgrp);
ddbcc7e8 864
81a6a5cd
PM
865 if (opts.release_agent)
866 strcpy(root->release_agent_path, opts.release_agent);
ddbcc7e8 867 out_unlock:
81a6a5cd
PM
868 if (opts.release_agent)
869 kfree(opts.release_agent);
ddbcc7e8 870 mutex_unlock(&cgroup_mutex);
bd89aabc 871 mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
ddbcc7e8
PM
872 return ret;
873}
874
875static struct super_operations cgroup_ops = {
876 .statfs = simple_statfs,
877 .drop_inode = generic_delete_inode,
878 .show_options = cgroup_show_options,
879 .remount_fs = cgroup_remount,
880};
881
cc31edce
PM
882static void init_cgroup_housekeeping(struct cgroup *cgrp)
883{
884 INIT_LIST_HEAD(&cgrp->sibling);
885 INIT_LIST_HEAD(&cgrp->children);
886 INIT_LIST_HEAD(&cgrp->css_sets);
887 INIT_LIST_HEAD(&cgrp->release_list);
888 init_rwsem(&cgrp->pids_mutex);
889}
ddbcc7e8
PM
890static void init_cgroup_root(struct cgroupfs_root *root)
891{
bd89aabc 892 struct cgroup *cgrp = &root->top_cgroup;
ddbcc7e8
PM
893 INIT_LIST_HEAD(&root->subsys_list);
894 INIT_LIST_HEAD(&root->root_list);
895 root->number_of_cgroups = 1;
bd89aabc
PM
896 cgrp->root = root;
897 cgrp->top_cgroup = cgrp;
cc31edce 898 init_cgroup_housekeeping(cgrp);
ddbcc7e8
PM
899}
900
901static int cgroup_test_super(struct super_block *sb, void *data)
902{
903 struct cgroupfs_root *new = data;
904 struct cgroupfs_root *root = sb->s_fs_info;
905
906 /* First check subsystems */
907 if (new->subsys_bits != root->subsys_bits)
908 return 0;
909
910 /* Next check flags */
911 if (new->flags != root->flags)
912 return 0;
913
914 return 1;
915}
916
917static int cgroup_set_super(struct super_block *sb, void *data)
918{
919 int ret;
920 struct cgroupfs_root *root = data;
921
922 ret = set_anon_super(sb, NULL);
923 if (ret)
924 return ret;
925
926 sb->s_fs_info = root;
927 root->sb = sb;
928
929 sb->s_blocksize = PAGE_CACHE_SIZE;
930 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
931 sb->s_magic = CGROUP_SUPER_MAGIC;
932 sb->s_op = &cgroup_ops;
933
934 return 0;
935}
936
937static int cgroup_get_rootdir(struct super_block *sb)
938{
939 struct inode *inode =
940 cgroup_new_inode(S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR, sb);
941 struct dentry *dentry;
942
943 if (!inode)
944 return -ENOMEM;
945
ddbcc7e8
PM
946 inode->i_fop = &simple_dir_operations;
947 inode->i_op = &cgroup_dir_inode_operations;
948 /* directories start off with i_nlink == 2 (for "." entry) */
949 inc_nlink(inode);
950 dentry = d_alloc_root(inode);
951 if (!dentry) {
952 iput(inode);
953 return -ENOMEM;
954 }
955 sb->s_root = dentry;
956 return 0;
957}
958
959static int cgroup_get_sb(struct file_system_type *fs_type,
960 int flags, const char *unused_dev_name,
961 void *data, struct vfsmount *mnt)
962{
963 struct cgroup_sb_opts opts;
964 int ret = 0;
965 struct super_block *sb;
966 struct cgroupfs_root *root;
28fd5dfc 967 struct list_head tmp_cg_links;
ddbcc7e8
PM
968
969 /* First find the desired set of subsystems */
970 ret = parse_cgroupfs_options(data, &opts);
81a6a5cd
PM
971 if (ret) {
972 if (opts.release_agent)
973 kfree(opts.release_agent);
ddbcc7e8 974 return ret;
81a6a5cd 975 }
ddbcc7e8
PM
976
977 root = kzalloc(sizeof(*root), GFP_KERNEL);
f7770738
LZ
978 if (!root) {
979 if (opts.release_agent)
980 kfree(opts.release_agent);
ddbcc7e8 981 return -ENOMEM;
f7770738 982 }
ddbcc7e8
PM
983
984 init_cgroup_root(root);
985 root->subsys_bits = opts.subsys_bits;
986 root->flags = opts.flags;
81a6a5cd
PM
987 if (opts.release_agent) {
988 strcpy(root->release_agent_path, opts.release_agent);
989 kfree(opts.release_agent);
990 }
ddbcc7e8
PM
991
992 sb = sget(fs_type, cgroup_test_super, cgroup_set_super, root);
993
994 if (IS_ERR(sb)) {
995 kfree(root);
996 return PTR_ERR(sb);
997 }
998
999 if (sb->s_fs_info != root) {
1000 /* Reusing an existing superblock */
1001 BUG_ON(sb->s_root == NULL);
1002 kfree(root);
1003 root = NULL;
1004 } else {
1005 /* New superblock */
c12f65d4 1006 struct cgroup *root_cgrp = &root->top_cgroup;
817929ec 1007 struct inode *inode;
28fd5dfc 1008 int i;
ddbcc7e8
PM
1009
1010 BUG_ON(sb->s_root != NULL);
1011
1012 ret = cgroup_get_rootdir(sb);
1013 if (ret)
1014 goto drop_new_super;
817929ec 1015 inode = sb->s_root->d_inode;
ddbcc7e8 1016
817929ec 1017 mutex_lock(&inode->i_mutex);
ddbcc7e8
PM
1018 mutex_lock(&cgroup_mutex);
1019
817929ec
PM
1020 /*
1021 * We're accessing css_set_count without locking
1022 * css_set_lock here, but that's OK - it can only be
1023 * increased by someone holding cgroup_lock, and
1024 * that's us. The worst that can happen is that we
1025 * have some link structures left over
1026 */
1027 ret = allocate_cg_links(css_set_count, &tmp_cg_links);
1028 if (ret) {
1029 mutex_unlock(&cgroup_mutex);
1030 mutex_unlock(&inode->i_mutex);
1031 goto drop_new_super;
1032 }
1033
ddbcc7e8
PM
1034 ret = rebind_subsystems(root, root->subsys_bits);
1035 if (ret == -EBUSY) {
1036 mutex_unlock(&cgroup_mutex);
817929ec 1037 mutex_unlock(&inode->i_mutex);
20ca9b3f 1038 goto free_cg_links;
ddbcc7e8
PM
1039 }
1040
1041 /* EBUSY should be the only error here */
1042 BUG_ON(ret);
1043
1044 list_add(&root->root_list, &roots);
817929ec 1045 root_count++;
ddbcc7e8 1046
c12f65d4 1047 sb->s_root->d_fsdata = root_cgrp;
ddbcc7e8
PM
1048 root->top_cgroup.dentry = sb->s_root;
1049
817929ec
PM
1050 /* Link the top cgroup in this hierarchy into all
1051 * the css_set objects */
1052 write_lock(&css_set_lock);
28fd5dfc
LZ
1053 for (i = 0; i < CSS_SET_TABLE_SIZE; i++) {
1054 struct hlist_head *hhead = &css_set_table[i];
1055 struct hlist_node *node;
817929ec 1056 struct css_set *cg;
28fd5dfc 1057
c12f65d4
LZ
1058 hlist_for_each_entry(cg, node, hhead, hlist)
1059 link_css_set(&tmp_cg_links, cg, root_cgrp);
28fd5dfc 1060 }
817929ec
PM
1061 write_unlock(&css_set_lock);
1062
1063 free_cg_links(&tmp_cg_links);
1064
c12f65d4
LZ
1065 BUG_ON(!list_empty(&root_cgrp->sibling));
1066 BUG_ON(!list_empty(&root_cgrp->children));
ddbcc7e8
PM
1067 BUG_ON(root->number_of_cgroups != 1);
1068
c12f65d4 1069 cgroup_populate_dir(root_cgrp);
817929ec 1070 mutex_unlock(&inode->i_mutex);
ddbcc7e8
PM
1071 mutex_unlock(&cgroup_mutex);
1072 }
1073
1074 return simple_set_mnt(mnt, sb);
1075
20ca9b3f
LZ
1076 free_cg_links:
1077 free_cg_links(&tmp_cg_links);
ddbcc7e8
PM
1078 drop_new_super:
1079 up_write(&sb->s_umount);
1080 deactivate_super(sb);
1081 return ret;
1082}
1083
1084static void cgroup_kill_sb(struct super_block *sb) {
1085 struct cgroupfs_root *root = sb->s_fs_info;
bd89aabc 1086 struct cgroup *cgrp = &root->top_cgroup;
ddbcc7e8 1087 int ret;
71cbb949
KM
1088 struct cg_cgroup_link *link;
1089 struct cg_cgroup_link *saved_link;
ddbcc7e8
PM
1090
1091 BUG_ON(!root);
1092
1093 BUG_ON(root->number_of_cgroups != 1);
bd89aabc
PM
1094 BUG_ON(!list_empty(&cgrp->children));
1095 BUG_ON(!list_empty(&cgrp->sibling));
ddbcc7e8
PM
1096
1097 mutex_lock(&cgroup_mutex);
1098
1099 /* Rebind all subsystems back to the default hierarchy */
1100 ret = rebind_subsystems(root, 0);
1101 /* Shouldn't be able to fail ... */
1102 BUG_ON(ret);
1103
817929ec
PM
1104 /*
1105 * Release all the links from css_sets to this hierarchy's
1106 * root cgroup
1107 */
1108 write_lock(&css_set_lock);
71cbb949
KM
1109
1110 list_for_each_entry_safe(link, saved_link, &cgrp->css_sets,
1111 cgrp_link_list) {
817929ec 1112 list_del(&link->cg_link_list);
bd89aabc 1113 list_del(&link->cgrp_link_list);
817929ec
PM
1114 kfree(link);
1115 }
1116 write_unlock(&css_set_lock);
1117
e5f6a860
LZ
1118 list_del(&root->root_list);
1119 root_count--;
1120
ddbcc7e8
PM
1121 mutex_unlock(&cgroup_mutex);
1122
1123 kfree(root);
1124 kill_litter_super(sb);
1125}
1126
1127static struct file_system_type cgroup_fs_type = {
1128 .name = "cgroup",
1129 .get_sb = cgroup_get_sb,
1130 .kill_sb = cgroup_kill_sb,
1131};
1132
bd89aabc 1133static inline struct cgroup *__d_cgrp(struct dentry *dentry)
ddbcc7e8
PM
1134{
1135 return dentry->d_fsdata;
1136}
1137
1138static inline struct cftype *__d_cft(struct dentry *dentry)
1139{
1140 return dentry->d_fsdata;
1141}
1142
a043e3b2
LZ
1143/**
1144 * cgroup_path - generate the path of a cgroup
1145 * @cgrp: the cgroup in question
1146 * @buf: the buffer to write the path into
1147 * @buflen: the length of the buffer
1148 *
a47295e6
PM
1149 * Called with cgroup_mutex held or else with an RCU-protected cgroup
1150 * reference. Writes path of cgroup into buf. Returns 0 on success,
1151 * -errno on error.
ddbcc7e8 1152 */
bd89aabc 1153int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen)
ddbcc7e8
PM
1154{
1155 char *start;
a47295e6 1156 struct dentry *dentry = rcu_dereference(cgrp->dentry);
ddbcc7e8 1157
a47295e6 1158 if (!dentry || cgrp == dummytop) {
ddbcc7e8
PM
1159 /*
1160 * Inactive subsystems have no dentry for their root
1161 * cgroup
1162 */
1163 strcpy(buf, "/");
1164 return 0;
1165 }
1166
1167 start = buf + buflen;
1168
1169 *--start = '\0';
1170 for (;;) {
a47295e6 1171 int len = dentry->d_name.len;
ddbcc7e8
PM
1172 if ((start -= len) < buf)
1173 return -ENAMETOOLONG;
bd89aabc
PM
1174 memcpy(start, cgrp->dentry->d_name.name, len);
1175 cgrp = cgrp->parent;
1176 if (!cgrp)
ddbcc7e8 1177 break;
a47295e6 1178 dentry = rcu_dereference(cgrp->dentry);
bd89aabc 1179 if (!cgrp->parent)
ddbcc7e8
PM
1180 continue;
1181 if (--start < buf)
1182 return -ENAMETOOLONG;
1183 *start = '/';
1184 }
1185 memmove(buf, start, buf + buflen - start);
1186 return 0;
1187}
1188
bbcb81d0
PM
1189/*
1190 * Return the first subsystem attached to a cgroup's hierarchy, and
1191 * its subsystem id.
1192 */
1193
bd89aabc 1194static void get_first_subsys(const struct cgroup *cgrp,
bbcb81d0
PM
1195 struct cgroup_subsys_state **css, int *subsys_id)
1196{
bd89aabc 1197 const struct cgroupfs_root *root = cgrp->root;
bbcb81d0
PM
1198 const struct cgroup_subsys *test_ss;
1199 BUG_ON(list_empty(&root->subsys_list));
1200 test_ss = list_entry(root->subsys_list.next,
1201 struct cgroup_subsys, sibling);
1202 if (css) {
bd89aabc 1203 *css = cgrp->subsys[test_ss->subsys_id];
bbcb81d0
PM
1204 BUG_ON(!*css);
1205 }
1206 if (subsys_id)
1207 *subsys_id = test_ss->subsys_id;
1208}
1209
a043e3b2
LZ
1210/**
1211 * cgroup_attach_task - attach task 'tsk' to cgroup 'cgrp'
1212 * @cgrp: the cgroup the task is attaching to
1213 * @tsk: the task to be attached
bbcb81d0 1214 *
a043e3b2
LZ
1215 * Call holding cgroup_mutex. May take task_lock of
1216 * the task 'tsk' during call.
bbcb81d0 1217 */
956db3ca 1218int cgroup_attach_task(struct cgroup *cgrp, struct task_struct *tsk)
bbcb81d0
PM
1219{
1220 int retval = 0;
1221 struct cgroup_subsys *ss;
bd89aabc 1222 struct cgroup *oldcgrp;
77efecd9 1223 struct css_set *cg;
817929ec 1224 struct css_set *newcg;
bd89aabc 1225 struct cgroupfs_root *root = cgrp->root;
bbcb81d0
PM
1226 int subsys_id;
1227
bd89aabc 1228 get_first_subsys(cgrp, NULL, &subsys_id);
bbcb81d0
PM
1229
1230 /* Nothing to do if the task is already in that cgroup */
bd89aabc
PM
1231 oldcgrp = task_cgroup(tsk, subsys_id);
1232 if (cgrp == oldcgrp)
bbcb81d0
PM
1233 return 0;
1234
1235 for_each_subsys(root, ss) {
1236 if (ss->can_attach) {
bd89aabc 1237 retval = ss->can_attach(ss, cgrp, tsk);
e18f6318 1238 if (retval)
bbcb81d0 1239 return retval;
bbcb81d0
PM
1240 }
1241 }
1242
77efecd9
LJ
1243 task_lock(tsk);
1244 cg = tsk->cgroups;
1245 get_css_set(cg);
1246 task_unlock(tsk);
817929ec
PM
1247 /*
1248 * Locate or allocate a new css_set for this task,
1249 * based on its final set of cgroups
1250 */
bd89aabc 1251 newcg = find_css_set(cg, cgrp);
77efecd9 1252 put_css_set(cg);
e18f6318 1253 if (!newcg)
817929ec 1254 return -ENOMEM;
817929ec 1255
bbcb81d0
PM
1256 task_lock(tsk);
1257 if (tsk->flags & PF_EXITING) {
1258 task_unlock(tsk);
817929ec 1259 put_css_set(newcg);
bbcb81d0
PM
1260 return -ESRCH;
1261 }
817929ec 1262 rcu_assign_pointer(tsk->cgroups, newcg);
bbcb81d0
PM
1263 task_unlock(tsk);
1264
817929ec
PM
1265 /* Update the css_set linked lists if we're using them */
1266 write_lock(&css_set_lock);
1267 if (!list_empty(&tsk->cg_list)) {
1268 list_del(&tsk->cg_list);
1269 list_add(&tsk->cg_list, &newcg->tasks);
1270 }
1271 write_unlock(&css_set_lock);
1272
bbcb81d0 1273 for_each_subsys(root, ss) {
e18f6318 1274 if (ss->attach)
bd89aabc 1275 ss->attach(ss, cgrp, oldcgrp, tsk);
bbcb81d0 1276 }
bd89aabc 1277 set_bit(CGRP_RELEASABLE, &oldcgrp->flags);
bbcb81d0 1278 synchronize_rcu();
817929ec 1279 put_css_set(cg);
bbcb81d0
PM
1280 return 0;
1281}
1282
1283/*
af351026
PM
1284 * Attach task with pid 'pid' to cgroup 'cgrp'. Call with cgroup_mutex
1285 * held. May take task_lock of task
bbcb81d0 1286 */
af351026 1287static int attach_task_by_pid(struct cgroup *cgrp, u64 pid)
bbcb81d0 1288{
bbcb81d0 1289 struct task_struct *tsk;
c69e8d9c 1290 const struct cred *cred = current_cred(), *tcred;
bbcb81d0
PM
1291 int ret;
1292
bbcb81d0
PM
1293 if (pid) {
1294 rcu_read_lock();
73507f33 1295 tsk = find_task_by_vpid(pid);
bbcb81d0
PM
1296 if (!tsk || tsk->flags & PF_EXITING) {
1297 rcu_read_unlock();
1298 return -ESRCH;
1299 }
bbcb81d0 1300
c69e8d9c
DH
1301 tcred = __task_cred(tsk);
1302 if (cred->euid &&
1303 cred->euid != tcred->uid &&
1304 cred->euid != tcred->suid) {
1305 rcu_read_unlock();
bbcb81d0
PM
1306 return -EACCES;
1307 }
c69e8d9c
DH
1308 get_task_struct(tsk);
1309 rcu_read_unlock();
bbcb81d0
PM
1310 } else {
1311 tsk = current;
1312 get_task_struct(tsk);
1313 }
1314
956db3ca 1315 ret = cgroup_attach_task(cgrp, tsk);
bbcb81d0
PM
1316 put_task_struct(tsk);
1317 return ret;
1318}
1319
af351026
PM
1320static int cgroup_tasks_write(struct cgroup *cgrp, struct cftype *cft, u64 pid)
1321{
1322 int ret;
1323 if (!cgroup_lock_live_group(cgrp))
1324 return -ENODEV;
1325 ret = attach_task_by_pid(cgrp, pid);
1326 cgroup_unlock();
1327 return ret;
1328}
1329
ddbcc7e8 1330/* The various types of files and directories in a cgroup file system */
ddbcc7e8
PM
1331enum cgroup_filetype {
1332 FILE_ROOT,
1333 FILE_DIR,
1334 FILE_TASKLIST,
81a6a5cd 1335 FILE_NOTIFY_ON_RELEASE,
81a6a5cd 1336 FILE_RELEASE_AGENT,
ddbcc7e8
PM
1337};
1338
e788e066
PM
1339/**
1340 * cgroup_lock_live_group - take cgroup_mutex and check that cgrp is alive.
1341 * @cgrp: the cgroup to be checked for liveness
1342 *
84eea842
PM
1343 * On success, returns true; the lock should be later released with
1344 * cgroup_unlock(). On failure returns false with no lock held.
e788e066 1345 */
84eea842 1346bool cgroup_lock_live_group(struct cgroup *cgrp)
e788e066
PM
1347{
1348 mutex_lock(&cgroup_mutex);
1349 if (cgroup_is_removed(cgrp)) {
1350 mutex_unlock(&cgroup_mutex);
1351 return false;
1352 }
1353 return true;
1354}
1355
1356static int cgroup_release_agent_write(struct cgroup *cgrp, struct cftype *cft,
1357 const char *buffer)
1358{
1359 BUILD_BUG_ON(sizeof(cgrp->root->release_agent_path) < PATH_MAX);
1360 if (!cgroup_lock_live_group(cgrp))
1361 return -ENODEV;
1362 strcpy(cgrp->root->release_agent_path, buffer);
84eea842 1363 cgroup_unlock();
e788e066
PM
1364 return 0;
1365}
1366
1367static int cgroup_release_agent_show(struct cgroup *cgrp, struct cftype *cft,
1368 struct seq_file *seq)
1369{
1370 if (!cgroup_lock_live_group(cgrp))
1371 return -ENODEV;
1372 seq_puts(seq, cgrp->root->release_agent_path);
1373 seq_putc(seq, '\n');
84eea842 1374 cgroup_unlock();
e788e066
PM
1375 return 0;
1376}
1377
84eea842
PM
1378/* A buffer size big enough for numbers or short strings */
1379#define CGROUP_LOCAL_BUFFER_SIZE 64
1380
e73d2c61 1381static ssize_t cgroup_write_X64(struct cgroup *cgrp, struct cftype *cft,
f4c753b7
PM
1382 struct file *file,
1383 const char __user *userbuf,
1384 size_t nbytes, loff_t *unused_ppos)
355e0c48 1385{
84eea842 1386 char buffer[CGROUP_LOCAL_BUFFER_SIZE];
355e0c48 1387 int retval = 0;
355e0c48
PM
1388 char *end;
1389
1390 if (!nbytes)
1391 return -EINVAL;
1392 if (nbytes >= sizeof(buffer))
1393 return -E2BIG;
1394 if (copy_from_user(buffer, userbuf, nbytes))
1395 return -EFAULT;
1396
1397 buffer[nbytes] = 0; /* nul-terminate */
b7269dfc 1398 strstrip(buffer);
e73d2c61
PM
1399 if (cft->write_u64) {
1400 u64 val = simple_strtoull(buffer, &end, 0);
1401 if (*end)
1402 return -EINVAL;
1403 retval = cft->write_u64(cgrp, cft, val);
1404 } else {
1405 s64 val = simple_strtoll(buffer, &end, 0);
1406 if (*end)
1407 return -EINVAL;
1408 retval = cft->write_s64(cgrp, cft, val);
1409 }
355e0c48
PM
1410 if (!retval)
1411 retval = nbytes;
1412 return retval;
1413}
1414
db3b1497
PM
1415static ssize_t cgroup_write_string(struct cgroup *cgrp, struct cftype *cft,
1416 struct file *file,
1417 const char __user *userbuf,
1418 size_t nbytes, loff_t *unused_ppos)
1419{
84eea842 1420 char local_buffer[CGROUP_LOCAL_BUFFER_SIZE];
db3b1497
PM
1421 int retval = 0;
1422 size_t max_bytes = cft->max_write_len;
1423 char *buffer = local_buffer;
1424
1425 if (!max_bytes)
1426 max_bytes = sizeof(local_buffer) - 1;
1427 if (nbytes >= max_bytes)
1428 return -E2BIG;
1429 /* Allocate a dynamic buffer if we need one */
1430 if (nbytes >= sizeof(local_buffer)) {
1431 buffer = kmalloc(nbytes + 1, GFP_KERNEL);
1432 if (buffer == NULL)
1433 return -ENOMEM;
1434 }
5a3eb9f6
LZ
1435 if (nbytes && copy_from_user(buffer, userbuf, nbytes)) {
1436 retval = -EFAULT;
1437 goto out;
1438 }
db3b1497
PM
1439
1440 buffer[nbytes] = 0; /* nul-terminate */
1441 strstrip(buffer);
1442 retval = cft->write_string(cgrp, cft, buffer);
1443 if (!retval)
1444 retval = nbytes;
5a3eb9f6 1445out:
db3b1497
PM
1446 if (buffer != local_buffer)
1447 kfree(buffer);
1448 return retval;
1449}
1450
ddbcc7e8
PM
1451static ssize_t cgroup_file_write(struct file *file, const char __user *buf,
1452 size_t nbytes, loff_t *ppos)
1453{
1454 struct cftype *cft = __d_cft(file->f_dentry);
bd89aabc 1455 struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
ddbcc7e8 1456
75139b82 1457 if (cgroup_is_removed(cgrp))
ddbcc7e8 1458 return -ENODEV;
355e0c48 1459 if (cft->write)
bd89aabc 1460 return cft->write(cgrp, cft, file, buf, nbytes, ppos);
e73d2c61
PM
1461 if (cft->write_u64 || cft->write_s64)
1462 return cgroup_write_X64(cgrp, cft, file, buf, nbytes, ppos);
db3b1497
PM
1463 if (cft->write_string)
1464 return cgroup_write_string(cgrp, cft, file, buf, nbytes, ppos);
d447ea2f
PE
1465 if (cft->trigger) {
1466 int ret = cft->trigger(cgrp, (unsigned int)cft->private);
1467 return ret ? ret : nbytes;
1468 }
355e0c48 1469 return -EINVAL;
ddbcc7e8
PM
1470}
1471
f4c753b7
PM
1472static ssize_t cgroup_read_u64(struct cgroup *cgrp, struct cftype *cft,
1473 struct file *file,
1474 char __user *buf, size_t nbytes,
1475 loff_t *ppos)
ddbcc7e8 1476{
84eea842 1477 char tmp[CGROUP_LOCAL_BUFFER_SIZE];
f4c753b7 1478 u64 val = cft->read_u64(cgrp, cft);
ddbcc7e8
PM
1479 int len = sprintf(tmp, "%llu\n", (unsigned long long) val);
1480
1481 return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
1482}
1483
e73d2c61
PM
1484static ssize_t cgroup_read_s64(struct cgroup *cgrp, struct cftype *cft,
1485 struct file *file,
1486 char __user *buf, size_t nbytes,
1487 loff_t *ppos)
1488{
84eea842 1489 char tmp[CGROUP_LOCAL_BUFFER_SIZE];
e73d2c61
PM
1490 s64 val = cft->read_s64(cgrp, cft);
1491 int len = sprintf(tmp, "%lld\n", (long long) val);
1492
1493 return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
1494}
1495
ddbcc7e8
PM
1496static ssize_t cgroup_file_read(struct file *file, char __user *buf,
1497 size_t nbytes, loff_t *ppos)
1498{
1499 struct cftype *cft = __d_cft(file->f_dentry);
bd89aabc 1500 struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
ddbcc7e8 1501
75139b82 1502 if (cgroup_is_removed(cgrp))
ddbcc7e8
PM
1503 return -ENODEV;
1504
1505 if (cft->read)
bd89aabc 1506 return cft->read(cgrp, cft, file, buf, nbytes, ppos);
f4c753b7
PM
1507 if (cft->read_u64)
1508 return cgroup_read_u64(cgrp, cft, file, buf, nbytes, ppos);
e73d2c61
PM
1509 if (cft->read_s64)
1510 return cgroup_read_s64(cgrp, cft, file, buf, nbytes, ppos);
ddbcc7e8
PM
1511 return -EINVAL;
1512}
1513
91796569
PM
1514/*
1515 * seqfile ops/methods for returning structured data. Currently just
1516 * supports string->u64 maps, but can be extended in future.
1517 */
1518
1519struct cgroup_seqfile_state {
1520 struct cftype *cft;
1521 struct cgroup *cgroup;
1522};
1523
1524static int cgroup_map_add(struct cgroup_map_cb *cb, const char *key, u64 value)
1525{
1526 struct seq_file *sf = cb->state;
1527 return seq_printf(sf, "%s %llu\n", key, (unsigned long long)value);
1528}
1529
1530static int cgroup_seqfile_show(struct seq_file *m, void *arg)
1531{
1532 struct cgroup_seqfile_state *state = m->private;
1533 struct cftype *cft = state->cft;
29486df3
SH
1534 if (cft->read_map) {
1535 struct cgroup_map_cb cb = {
1536 .fill = cgroup_map_add,
1537 .state = m,
1538 };
1539 return cft->read_map(state->cgroup, cft, &cb);
1540 }
1541 return cft->read_seq_string(state->cgroup, cft, m);
91796569
PM
1542}
1543
96930a63 1544static int cgroup_seqfile_release(struct inode *inode, struct file *file)
91796569
PM
1545{
1546 struct seq_file *seq = file->private_data;
1547 kfree(seq->private);
1548 return single_release(inode, file);
1549}
1550
1551static struct file_operations cgroup_seqfile_operations = {
1552 .read = seq_read,
e788e066 1553 .write = cgroup_file_write,
91796569
PM
1554 .llseek = seq_lseek,
1555 .release = cgroup_seqfile_release,
1556};
1557
ddbcc7e8
PM
1558static int cgroup_file_open(struct inode *inode, struct file *file)
1559{
1560 int err;
1561 struct cftype *cft;
1562
1563 err = generic_file_open(inode, file);
1564 if (err)
1565 return err;
ddbcc7e8 1566 cft = __d_cft(file->f_dentry);
75139b82 1567
29486df3 1568 if (cft->read_map || cft->read_seq_string) {
91796569
PM
1569 struct cgroup_seqfile_state *state =
1570 kzalloc(sizeof(*state), GFP_USER);
1571 if (!state)
1572 return -ENOMEM;
1573 state->cft = cft;
1574 state->cgroup = __d_cgrp(file->f_dentry->d_parent);
1575 file->f_op = &cgroup_seqfile_operations;
1576 err = single_open(file, cgroup_seqfile_show, state);
1577 if (err < 0)
1578 kfree(state);
1579 } else if (cft->open)
ddbcc7e8
PM
1580 err = cft->open(inode, file);
1581 else
1582 err = 0;
1583
1584 return err;
1585}
1586
1587static int cgroup_file_release(struct inode *inode, struct file *file)
1588{
1589 struct cftype *cft = __d_cft(file->f_dentry);
1590 if (cft->release)
1591 return cft->release(inode, file);
1592 return 0;
1593}
1594
1595/*
1596 * cgroup_rename - Only allow simple rename of directories in place.
1597 */
1598static int cgroup_rename(struct inode *old_dir, struct dentry *old_dentry,
1599 struct inode *new_dir, struct dentry *new_dentry)
1600{
1601 if (!S_ISDIR(old_dentry->d_inode->i_mode))
1602 return -ENOTDIR;
1603 if (new_dentry->d_inode)
1604 return -EEXIST;
1605 if (old_dir != new_dir)
1606 return -EIO;
1607 return simple_rename(old_dir, old_dentry, new_dir, new_dentry);
1608}
1609
1610static struct file_operations cgroup_file_operations = {
1611 .read = cgroup_file_read,
1612 .write = cgroup_file_write,
1613 .llseek = generic_file_llseek,
1614 .open = cgroup_file_open,
1615 .release = cgroup_file_release,
1616};
1617
1618static struct inode_operations cgroup_dir_inode_operations = {
1619 .lookup = simple_lookup,
1620 .mkdir = cgroup_mkdir,
1621 .rmdir = cgroup_rmdir,
1622 .rename = cgroup_rename,
1623};
1624
1625static int cgroup_create_file(struct dentry *dentry, int mode,
1626 struct super_block *sb)
1627{
1628 static struct dentry_operations cgroup_dops = {
1629 .d_iput = cgroup_diput,
1630 };
1631
1632 struct inode *inode;
1633
1634 if (!dentry)
1635 return -ENOENT;
1636 if (dentry->d_inode)
1637 return -EEXIST;
1638
1639 inode = cgroup_new_inode(mode, sb);
1640 if (!inode)
1641 return -ENOMEM;
1642
1643 if (S_ISDIR(mode)) {
1644 inode->i_op = &cgroup_dir_inode_operations;
1645 inode->i_fop = &simple_dir_operations;
1646
1647 /* start off with i_nlink == 2 (for "." entry) */
1648 inc_nlink(inode);
1649
1650 /* start with the directory inode held, so that we can
1651 * populate it without racing with another mkdir */
817929ec 1652 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
ddbcc7e8
PM
1653 } else if (S_ISREG(mode)) {
1654 inode->i_size = 0;
1655 inode->i_fop = &cgroup_file_operations;
1656 }
1657 dentry->d_op = &cgroup_dops;
1658 d_instantiate(dentry, inode);
1659 dget(dentry); /* Extra count - pin the dentry in core */
1660 return 0;
1661}
1662
1663/*
a043e3b2
LZ
1664 * cgroup_create_dir - create a directory for an object.
1665 * @cgrp: the cgroup we create the directory for. It must have a valid
1666 * ->parent field. And we are going to fill its ->dentry field.
1667 * @dentry: dentry of the new cgroup
1668 * @mode: mode to set on new directory.
ddbcc7e8 1669 */
bd89aabc 1670static int cgroup_create_dir(struct cgroup *cgrp, struct dentry *dentry,
ddbcc7e8
PM
1671 int mode)
1672{
1673 struct dentry *parent;
1674 int error = 0;
1675
bd89aabc
PM
1676 parent = cgrp->parent->dentry;
1677 error = cgroup_create_file(dentry, S_IFDIR | mode, cgrp->root->sb);
ddbcc7e8 1678 if (!error) {
bd89aabc 1679 dentry->d_fsdata = cgrp;
ddbcc7e8 1680 inc_nlink(parent->d_inode);
a47295e6 1681 rcu_assign_pointer(cgrp->dentry, dentry);
ddbcc7e8
PM
1682 dget(dentry);
1683 }
1684 dput(dentry);
1685
1686 return error;
1687}
1688
bd89aabc 1689int cgroup_add_file(struct cgroup *cgrp,
ddbcc7e8
PM
1690 struct cgroup_subsys *subsys,
1691 const struct cftype *cft)
1692{
bd89aabc 1693 struct dentry *dir = cgrp->dentry;
ddbcc7e8
PM
1694 struct dentry *dentry;
1695 int error;
1696
1697 char name[MAX_CGROUP_TYPE_NAMELEN + MAX_CFTYPE_NAME + 2] = { 0 };
bd89aabc 1698 if (subsys && !test_bit(ROOT_NOPREFIX, &cgrp->root->flags)) {
ddbcc7e8
PM
1699 strcpy(name, subsys->name);
1700 strcat(name, ".");
1701 }
1702 strcat(name, cft->name);
1703 BUG_ON(!mutex_is_locked(&dir->d_inode->i_mutex));
1704 dentry = lookup_one_len(name, dir, strlen(name));
1705 if (!IS_ERR(dentry)) {
1706 error = cgroup_create_file(dentry, 0644 | S_IFREG,
bd89aabc 1707 cgrp->root->sb);
ddbcc7e8
PM
1708 if (!error)
1709 dentry->d_fsdata = (void *)cft;
1710 dput(dentry);
1711 } else
1712 error = PTR_ERR(dentry);
1713 return error;
1714}
1715
bd89aabc 1716int cgroup_add_files(struct cgroup *cgrp,
ddbcc7e8
PM
1717 struct cgroup_subsys *subsys,
1718 const struct cftype cft[],
1719 int count)
1720{
1721 int i, err;
1722 for (i = 0; i < count; i++) {
bd89aabc 1723 err = cgroup_add_file(cgrp, subsys, &cft[i]);
ddbcc7e8
PM
1724 if (err)
1725 return err;
1726 }
1727 return 0;
1728}
1729
a043e3b2
LZ
1730/**
1731 * cgroup_task_count - count the number of tasks in a cgroup.
1732 * @cgrp: the cgroup in question
1733 *
1734 * Return the number of tasks in the cgroup.
1735 */
bd89aabc 1736int cgroup_task_count(const struct cgroup *cgrp)
bbcb81d0
PM
1737{
1738 int count = 0;
71cbb949 1739 struct cg_cgroup_link *link;
817929ec
PM
1740
1741 read_lock(&css_set_lock);
71cbb949 1742 list_for_each_entry(link, &cgrp->css_sets, cgrp_link_list) {
146aa1bd 1743 count += atomic_read(&link->cg->refcount);
817929ec
PM
1744 }
1745 read_unlock(&css_set_lock);
bbcb81d0
PM
1746 return count;
1747}
1748
817929ec
PM
1749/*
1750 * Advance a list_head iterator. The iterator should be positioned at
1751 * the start of a css_set
1752 */
bd89aabc 1753static void cgroup_advance_iter(struct cgroup *cgrp,
817929ec
PM
1754 struct cgroup_iter *it)
1755{
1756 struct list_head *l = it->cg_link;
1757 struct cg_cgroup_link *link;
1758 struct css_set *cg;
1759
1760 /* Advance to the next non-empty css_set */
1761 do {
1762 l = l->next;
bd89aabc 1763 if (l == &cgrp->css_sets) {
817929ec
PM
1764 it->cg_link = NULL;
1765 return;
1766 }
bd89aabc 1767 link = list_entry(l, struct cg_cgroup_link, cgrp_link_list);
817929ec
PM
1768 cg = link->cg;
1769 } while (list_empty(&cg->tasks));
1770 it->cg_link = l;
1771 it->task = cg->tasks.next;
1772}
1773
31a7df01
CW
1774/*
1775 * To reduce the fork() overhead for systems that are not actually
1776 * using their cgroups capability, we don't maintain the lists running
1777 * through each css_set to its tasks until we see the list actually
1778 * used - in other words after the first call to cgroup_iter_start().
1779 *
1780 * The tasklist_lock is not held here, as do_each_thread() and
1781 * while_each_thread() are protected by RCU.
1782 */
3df91fe3 1783static void cgroup_enable_task_cg_lists(void)
31a7df01
CW
1784{
1785 struct task_struct *p, *g;
1786 write_lock(&css_set_lock);
1787 use_task_css_set_links = 1;
1788 do_each_thread(g, p) {
1789 task_lock(p);
0e04388f
LZ
1790 /*
1791 * We should check if the process is exiting, otherwise
1792 * it will race with cgroup_exit() in that the list
1793 * entry won't be deleted though the process has exited.
1794 */
1795 if (!(p->flags & PF_EXITING) && list_empty(&p->cg_list))
31a7df01
CW
1796 list_add(&p->cg_list, &p->cgroups->tasks);
1797 task_unlock(p);
1798 } while_each_thread(g, p);
1799 write_unlock(&css_set_lock);
1800}
1801
bd89aabc 1802void cgroup_iter_start(struct cgroup *cgrp, struct cgroup_iter *it)
817929ec
PM
1803{
1804 /*
1805 * The first time anyone tries to iterate across a cgroup,
1806 * we need to enable the list linking each css_set to its
1807 * tasks, and fix up all existing tasks.
1808 */
31a7df01
CW
1809 if (!use_task_css_set_links)
1810 cgroup_enable_task_cg_lists();
1811
817929ec 1812 read_lock(&css_set_lock);
bd89aabc
PM
1813 it->cg_link = &cgrp->css_sets;
1814 cgroup_advance_iter(cgrp, it);
817929ec
PM
1815}
1816
bd89aabc 1817struct task_struct *cgroup_iter_next(struct cgroup *cgrp,
817929ec
PM
1818 struct cgroup_iter *it)
1819{
1820 struct task_struct *res;
1821 struct list_head *l = it->task;
2019f634 1822 struct cg_cgroup_link *link;
817929ec
PM
1823
1824 /* If the iterator cg is NULL, we have no tasks */
1825 if (!it->cg_link)
1826 return NULL;
1827 res = list_entry(l, struct task_struct, cg_list);
1828 /* Advance iterator to find next entry */
1829 l = l->next;
2019f634
LJ
1830 link = list_entry(it->cg_link, struct cg_cgroup_link, cgrp_link_list);
1831 if (l == &link->cg->tasks) {
817929ec
PM
1832 /* We reached the end of this task list - move on to
1833 * the next cg_cgroup_link */
bd89aabc 1834 cgroup_advance_iter(cgrp, it);
817929ec
PM
1835 } else {
1836 it->task = l;
1837 }
1838 return res;
1839}
1840
bd89aabc 1841void cgroup_iter_end(struct cgroup *cgrp, struct cgroup_iter *it)
817929ec
PM
1842{
1843 read_unlock(&css_set_lock);
1844}
1845
31a7df01
CW
1846static inline int started_after_time(struct task_struct *t1,
1847 struct timespec *time,
1848 struct task_struct *t2)
1849{
1850 int start_diff = timespec_compare(&t1->start_time, time);
1851 if (start_diff > 0) {
1852 return 1;
1853 } else if (start_diff < 0) {
1854 return 0;
1855 } else {
1856 /*
1857 * Arbitrarily, if two processes started at the same
1858 * time, we'll say that the lower pointer value
1859 * started first. Note that t2 may have exited by now
1860 * so this may not be a valid pointer any longer, but
1861 * that's fine - it still serves to distinguish
1862 * between two tasks started (effectively) simultaneously.
1863 */
1864 return t1 > t2;
1865 }
1866}
1867
1868/*
1869 * This function is a callback from heap_insert() and is used to order
1870 * the heap.
1871 * In this case we order the heap in descending task start time.
1872 */
1873static inline int started_after(void *p1, void *p2)
1874{
1875 struct task_struct *t1 = p1;
1876 struct task_struct *t2 = p2;
1877 return started_after_time(t1, &t2->start_time, t2);
1878}
1879
1880/**
1881 * cgroup_scan_tasks - iterate though all the tasks in a cgroup
1882 * @scan: struct cgroup_scanner containing arguments for the scan
1883 *
1884 * Arguments include pointers to callback functions test_task() and
1885 * process_task().
1886 * Iterate through all the tasks in a cgroup, calling test_task() for each,
1887 * and if it returns true, call process_task() for it also.
1888 * The test_task pointer may be NULL, meaning always true (select all tasks).
1889 * Effectively duplicates cgroup_iter_{start,next,end}()
1890 * but does not lock css_set_lock for the call to process_task().
1891 * The struct cgroup_scanner may be embedded in any structure of the caller's
1892 * creation.
1893 * It is guaranteed that process_task() will act on every task that
1894 * is a member of the cgroup for the duration of this call. This
1895 * function may or may not call process_task() for tasks that exit
1896 * or move to a different cgroup during the call, or are forked or
1897 * move into the cgroup during the call.
1898 *
1899 * Note that test_task() may be called with locks held, and may in some
1900 * situations be called multiple times for the same task, so it should
1901 * be cheap.
1902 * If the heap pointer in the struct cgroup_scanner is non-NULL, a heap has been
1903 * pre-allocated and will be used for heap operations (and its "gt" member will
1904 * be overwritten), else a temporary heap will be used (allocation of which
1905 * may cause this function to fail).
1906 */
1907int cgroup_scan_tasks(struct cgroup_scanner *scan)
1908{
1909 int retval, i;
1910 struct cgroup_iter it;
1911 struct task_struct *p, *dropped;
1912 /* Never dereference latest_task, since it's not refcounted */
1913 struct task_struct *latest_task = NULL;
1914 struct ptr_heap tmp_heap;
1915 struct ptr_heap *heap;
1916 struct timespec latest_time = { 0, 0 };
1917
1918 if (scan->heap) {
1919 /* The caller supplied our heap and pre-allocated its memory */
1920 heap = scan->heap;
1921 heap->gt = &started_after;
1922 } else {
1923 /* We need to allocate our own heap memory */
1924 heap = &tmp_heap;
1925 retval = heap_init(heap, PAGE_SIZE, GFP_KERNEL, &started_after);
1926 if (retval)
1927 /* cannot allocate the heap */
1928 return retval;
1929 }
1930
1931 again:
1932 /*
1933 * Scan tasks in the cgroup, using the scanner's "test_task" callback
1934 * to determine which are of interest, and using the scanner's
1935 * "process_task" callback to process any of them that need an update.
1936 * Since we don't want to hold any locks during the task updates,
1937 * gather tasks to be processed in a heap structure.
1938 * The heap is sorted by descending task start time.
1939 * If the statically-sized heap fills up, we overflow tasks that
1940 * started later, and in future iterations only consider tasks that
1941 * started after the latest task in the previous pass. This
1942 * guarantees forward progress and that we don't miss any tasks.
1943 */
1944 heap->size = 0;
1945 cgroup_iter_start(scan->cg, &it);
1946 while ((p = cgroup_iter_next(scan->cg, &it))) {
1947 /*
1948 * Only affect tasks that qualify per the caller's callback,
1949 * if he provided one
1950 */
1951 if (scan->test_task && !scan->test_task(p, scan))
1952 continue;
1953 /*
1954 * Only process tasks that started after the last task
1955 * we processed
1956 */
1957 if (!started_after_time(p, &latest_time, latest_task))
1958 continue;
1959 dropped = heap_insert(heap, p);
1960 if (dropped == NULL) {
1961 /*
1962 * The new task was inserted; the heap wasn't
1963 * previously full
1964 */
1965 get_task_struct(p);
1966 } else if (dropped != p) {
1967 /*
1968 * The new task was inserted, and pushed out a
1969 * different task
1970 */
1971 get_task_struct(p);
1972 put_task_struct(dropped);
1973 }
1974 /*
1975 * Else the new task was newer than anything already in
1976 * the heap and wasn't inserted
1977 */
1978 }
1979 cgroup_iter_end(scan->cg, &it);
1980
1981 if (heap->size) {
1982 for (i = 0; i < heap->size; i++) {
4fe91d51 1983 struct task_struct *q = heap->ptrs[i];
31a7df01 1984 if (i == 0) {
4fe91d51
PJ
1985 latest_time = q->start_time;
1986 latest_task = q;
31a7df01
CW
1987 }
1988 /* Process the task per the caller's callback */
4fe91d51
PJ
1989 scan->process_task(q, scan);
1990 put_task_struct(q);
31a7df01
CW
1991 }
1992 /*
1993 * If we had to process any tasks at all, scan again
1994 * in case some of them were in the middle of forking
1995 * children that didn't get processed.
1996 * Not the most efficient way to do it, but it avoids
1997 * having to take callback_mutex in the fork path
1998 */
1999 goto again;
2000 }
2001 if (heap == &tmp_heap)
2002 heap_free(&tmp_heap);
2003 return 0;
2004}
2005
bbcb81d0
PM
2006/*
2007 * Stuff for reading the 'tasks' file.
2008 *
2009 * Reading this file can return large amounts of data if a cgroup has
2010 * *lots* of attached tasks. So it may need several calls to read(),
2011 * but we cannot guarantee that the information we produce is correct
2012 * unless we produce it entirely atomically.
2013 *
bbcb81d0 2014 */
bbcb81d0
PM
2015
2016/*
2017 * Load into 'pidarray' up to 'npids' of the tasks using cgroup
bd89aabc 2018 * 'cgrp'. Return actual number of pids loaded. No need to
bbcb81d0
PM
2019 * task_lock(p) when reading out p->cgroup, since we're in an RCU
2020 * read section, so the css_set can't go away, and is
2021 * immutable after creation.
2022 */
bd89aabc 2023static int pid_array_load(pid_t *pidarray, int npids, struct cgroup *cgrp)
bbcb81d0 2024{
e7b80bb6 2025 int n = 0, pid;
817929ec
PM
2026 struct cgroup_iter it;
2027 struct task_struct *tsk;
bd89aabc
PM
2028 cgroup_iter_start(cgrp, &it);
2029 while ((tsk = cgroup_iter_next(cgrp, &it))) {
817929ec
PM
2030 if (unlikely(n == npids))
2031 break;
e7b80bb6
G
2032 pid = task_pid_vnr(tsk);
2033 if (pid > 0)
2034 pidarray[n++] = pid;
817929ec 2035 }
bd89aabc 2036 cgroup_iter_end(cgrp, &it);
bbcb81d0
PM
2037 return n;
2038}
2039
846c7bb0 2040/**
a043e3b2 2041 * cgroupstats_build - build and fill cgroupstats
846c7bb0
BS
2042 * @stats: cgroupstats to fill information into
2043 * @dentry: A dentry entry belonging to the cgroup for which stats have
2044 * been requested.
a043e3b2
LZ
2045 *
2046 * Build and fill cgroupstats so that taskstats can export it to user
2047 * space.
846c7bb0
BS
2048 */
2049int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
2050{
2051 int ret = -EINVAL;
bd89aabc 2052 struct cgroup *cgrp;
846c7bb0
BS
2053 struct cgroup_iter it;
2054 struct task_struct *tsk;
33d283be 2055
846c7bb0 2056 /*
33d283be
LZ
2057 * Validate dentry by checking the superblock operations,
2058 * and make sure it's a directory.
846c7bb0 2059 */
33d283be
LZ
2060 if (dentry->d_sb->s_op != &cgroup_ops ||
2061 !S_ISDIR(dentry->d_inode->i_mode))
846c7bb0
BS
2062 goto err;
2063
2064 ret = 0;
bd89aabc 2065 cgrp = dentry->d_fsdata;
846c7bb0 2066
bd89aabc
PM
2067 cgroup_iter_start(cgrp, &it);
2068 while ((tsk = cgroup_iter_next(cgrp, &it))) {
846c7bb0
BS
2069 switch (tsk->state) {
2070 case TASK_RUNNING:
2071 stats->nr_running++;
2072 break;
2073 case TASK_INTERRUPTIBLE:
2074 stats->nr_sleeping++;
2075 break;
2076 case TASK_UNINTERRUPTIBLE:
2077 stats->nr_uninterruptible++;
2078 break;
2079 case TASK_STOPPED:
2080 stats->nr_stopped++;
2081 break;
2082 default:
2083 if (delayacct_is_task_waiting_on_io(tsk))
2084 stats->nr_io_wait++;
2085 break;
2086 }
2087 }
bd89aabc 2088 cgroup_iter_end(cgrp, &it);
846c7bb0 2089
846c7bb0
BS
2090err:
2091 return ret;
2092}
2093
bbcb81d0
PM
2094static int cmppid(const void *a, const void *b)
2095{
2096 return *(pid_t *)a - *(pid_t *)b;
2097}
2098
cc31edce 2099
bbcb81d0 2100/*
cc31edce
PM
2101 * seq_file methods for the "tasks" file. The seq_file position is the
2102 * next pid to display; the seq_file iterator is a pointer to the pid
2103 * in the cgroup->tasks_pids array.
bbcb81d0 2104 */
cc31edce
PM
2105
2106static void *cgroup_tasks_start(struct seq_file *s, loff_t *pos)
bbcb81d0 2107{
cc31edce
PM
2108 /*
2109 * Initially we receive a position value that corresponds to
2110 * one more than the last pid shown (or 0 on the first call or
2111 * after a seek to the start). Use a binary-search to find the
2112 * next pid to display, if any
2113 */
2114 struct cgroup *cgrp = s->private;
2115 int index = 0, pid = *pos;
2116 int *iter;
2117
2118 down_read(&cgrp->pids_mutex);
2119 if (pid) {
2120 int end = cgrp->pids_length;
20777766 2121
cc31edce
PM
2122 while (index < end) {
2123 int mid = (index + end) / 2;
2124 if (cgrp->tasks_pids[mid] == pid) {
2125 index = mid;
2126 break;
2127 } else if (cgrp->tasks_pids[mid] <= pid)
2128 index = mid + 1;
2129 else
2130 end = mid;
2131 }
2132 }
2133 /* If we're off the end of the array, we're done */
2134 if (index >= cgrp->pids_length)
2135 return NULL;
2136 /* Update the abstract position to be the actual pid that we found */
2137 iter = cgrp->tasks_pids + index;
2138 *pos = *iter;
2139 return iter;
2140}
2141
2142static void cgroup_tasks_stop(struct seq_file *s, void *v)
2143{
2144 struct cgroup *cgrp = s->private;
2145 up_read(&cgrp->pids_mutex);
2146}
2147
2148static void *cgroup_tasks_next(struct seq_file *s, void *v, loff_t *pos)
2149{
2150 struct cgroup *cgrp = s->private;
2151 int *p = v;
2152 int *end = cgrp->tasks_pids + cgrp->pids_length;
2153
2154 /*
2155 * Advance to the next pid in the array. If this goes off the
2156 * end, we're done
2157 */
2158 p++;
2159 if (p >= end) {
2160 return NULL;
2161 } else {
2162 *pos = *p;
2163 return p;
2164 }
2165}
2166
2167static int cgroup_tasks_show(struct seq_file *s, void *v)
2168{
2169 return seq_printf(s, "%d\n", *(int *)v);
2170}
bbcb81d0 2171
cc31edce
PM
2172static struct seq_operations cgroup_tasks_seq_operations = {
2173 .start = cgroup_tasks_start,
2174 .stop = cgroup_tasks_stop,
2175 .next = cgroup_tasks_next,
2176 .show = cgroup_tasks_show,
2177};
2178
2179static void release_cgroup_pid_array(struct cgroup *cgrp)
2180{
2181 down_write(&cgrp->pids_mutex);
2182 BUG_ON(!cgrp->pids_use_count);
2183 if (!--cgrp->pids_use_count) {
2184 kfree(cgrp->tasks_pids);
2185 cgrp->tasks_pids = NULL;
2186 cgrp->pids_length = 0;
2187 }
2188 up_write(&cgrp->pids_mutex);
bbcb81d0
PM
2189}
2190
cc31edce
PM
2191static int cgroup_tasks_release(struct inode *inode, struct file *file)
2192{
2193 struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
2194
2195 if (!(file->f_mode & FMODE_READ))
2196 return 0;
2197
2198 release_cgroup_pid_array(cgrp);
2199 return seq_release(inode, file);
2200}
2201
2202static struct file_operations cgroup_tasks_operations = {
2203 .read = seq_read,
2204 .llseek = seq_lseek,
2205 .write = cgroup_file_write,
2206 .release = cgroup_tasks_release,
2207};
2208
bbcb81d0 2209/*
cc31edce 2210 * Handle an open on 'tasks' file. Prepare an array containing the
bbcb81d0 2211 * process id's of tasks currently attached to the cgroup being opened.
bbcb81d0 2212 */
cc31edce 2213
bbcb81d0
PM
2214static int cgroup_tasks_open(struct inode *unused, struct file *file)
2215{
bd89aabc 2216 struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
bbcb81d0
PM
2217 pid_t *pidarray;
2218 int npids;
cc31edce 2219 int retval;
bbcb81d0 2220
cc31edce 2221 /* Nothing to do for write-only files */
bbcb81d0
PM
2222 if (!(file->f_mode & FMODE_READ))
2223 return 0;
2224
bbcb81d0
PM
2225 /*
2226 * If cgroup gets more users after we read count, we won't have
2227 * enough space - tough. This race is indistinguishable to the
2228 * caller from the case that the additional cgroup users didn't
2229 * show up until sometime later on.
2230 */
bd89aabc 2231 npids = cgroup_task_count(cgrp);
cc31edce
PM
2232 pidarray = kmalloc(npids * sizeof(pid_t), GFP_KERNEL);
2233 if (!pidarray)
2234 return -ENOMEM;
2235 npids = pid_array_load(pidarray, npids, cgrp);
2236 sort(pidarray, npids, sizeof(pid_t), cmppid, NULL);
bbcb81d0 2237
cc31edce
PM
2238 /*
2239 * Store the array in the cgroup, freeing the old
2240 * array if necessary
2241 */
2242 down_write(&cgrp->pids_mutex);
2243 kfree(cgrp->tasks_pids);
2244 cgrp->tasks_pids = pidarray;
2245 cgrp->pids_length = npids;
2246 cgrp->pids_use_count++;
2247 up_write(&cgrp->pids_mutex);
2248
2249 file->f_op = &cgroup_tasks_operations;
2250
2251 retval = seq_open(file, &cgroup_tasks_seq_operations);
2252 if (retval) {
2253 release_cgroup_pid_array(cgrp);
2254 return retval;
bbcb81d0 2255 }
cc31edce 2256 ((struct seq_file *)file->private_data)->private = cgrp;
bbcb81d0
PM
2257 return 0;
2258}
2259
bd89aabc 2260static u64 cgroup_read_notify_on_release(struct cgroup *cgrp,
81a6a5cd
PM
2261 struct cftype *cft)
2262{
bd89aabc 2263 return notify_on_release(cgrp);
81a6a5cd
PM
2264}
2265
6379c106
PM
2266static int cgroup_write_notify_on_release(struct cgroup *cgrp,
2267 struct cftype *cft,
2268 u64 val)
2269{
2270 clear_bit(CGRP_RELEASABLE, &cgrp->flags);
2271 if (val)
2272 set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
2273 else
2274 clear_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
2275 return 0;
2276}
2277
bbcb81d0
PM
2278/*
2279 * for the common functions, 'private' gives the type of file
2280 */
81a6a5cd
PM
2281static struct cftype files[] = {
2282 {
2283 .name = "tasks",
2284 .open = cgroup_tasks_open,
af351026 2285 .write_u64 = cgroup_tasks_write,
81a6a5cd
PM
2286 .release = cgroup_tasks_release,
2287 .private = FILE_TASKLIST,
2288 },
2289
2290 {
2291 .name = "notify_on_release",
f4c753b7 2292 .read_u64 = cgroup_read_notify_on_release,
6379c106 2293 .write_u64 = cgroup_write_notify_on_release,
81a6a5cd
PM
2294 .private = FILE_NOTIFY_ON_RELEASE,
2295 },
81a6a5cd
PM
2296};
2297
2298static struct cftype cft_release_agent = {
2299 .name = "release_agent",
e788e066
PM
2300 .read_seq_string = cgroup_release_agent_show,
2301 .write_string = cgroup_release_agent_write,
2302 .max_write_len = PATH_MAX,
81a6a5cd 2303 .private = FILE_RELEASE_AGENT,
bbcb81d0
PM
2304};
2305
bd89aabc 2306static int cgroup_populate_dir(struct cgroup *cgrp)
ddbcc7e8
PM
2307{
2308 int err;
2309 struct cgroup_subsys *ss;
2310
2311 /* First clear out any existing files */
bd89aabc 2312 cgroup_clear_directory(cgrp->dentry);
ddbcc7e8 2313
bd89aabc 2314 err = cgroup_add_files(cgrp, NULL, files, ARRAY_SIZE(files));
bbcb81d0
PM
2315 if (err < 0)
2316 return err;
2317
bd89aabc
PM
2318 if (cgrp == cgrp->top_cgroup) {
2319 if ((err = cgroup_add_file(cgrp, NULL, &cft_release_agent)) < 0)
81a6a5cd
PM
2320 return err;
2321 }
2322
bd89aabc
PM
2323 for_each_subsys(cgrp->root, ss) {
2324 if (ss->populate && (err = ss->populate(ss, cgrp)) < 0)
ddbcc7e8
PM
2325 return err;
2326 }
2327
2328 return 0;
2329}
2330
2331static void init_cgroup_css(struct cgroup_subsys_state *css,
2332 struct cgroup_subsys *ss,
bd89aabc 2333 struct cgroup *cgrp)
ddbcc7e8 2334{
bd89aabc 2335 css->cgroup = cgrp;
e7c5ec91 2336 atomic_set(&css->refcnt, 1);
ddbcc7e8 2337 css->flags = 0;
bd89aabc 2338 if (cgrp == dummytop)
ddbcc7e8 2339 set_bit(CSS_ROOT, &css->flags);
bd89aabc
PM
2340 BUG_ON(cgrp->subsys[ss->subsys_id]);
2341 cgrp->subsys[ss->subsys_id] = css;
ddbcc7e8
PM
2342}
2343
999cd8a4
PM
2344static void cgroup_lock_hierarchy(struct cgroupfs_root *root)
2345{
2346 /* We need to take each hierarchy_mutex in a consistent order */
2347 int i;
2348
2349 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2350 struct cgroup_subsys *ss = subsys[i];
2351 if (ss->root == root)
2352 mutex_lock_nested(&ss->hierarchy_mutex, i);
2353 }
2354}
2355
2356static void cgroup_unlock_hierarchy(struct cgroupfs_root *root)
2357{
2358 int i;
2359
2360 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2361 struct cgroup_subsys *ss = subsys[i];
2362 if (ss->root == root)
2363 mutex_unlock(&ss->hierarchy_mutex);
2364 }
2365}
2366
ddbcc7e8 2367/*
a043e3b2
LZ
2368 * cgroup_create - create a cgroup
2369 * @parent: cgroup that will be parent of the new cgroup
2370 * @dentry: dentry of the new cgroup
2371 * @mode: mode to set on new inode
ddbcc7e8 2372 *
a043e3b2 2373 * Must be called with the mutex on the parent inode held
ddbcc7e8 2374 */
ddbcc7e8
PM
2375static long cgroup_create(struct cgroup *parent, struct dentry *dentry,
2376 int mode)
2377{
bd89aabc 2378 struct cgroup *cgrp;
ddbcc7e8
PM
2379 struct cgroupfs_root *root = parent->root;
2380 int err = 0;
2381 struct cgroup_subsys *ss;
2382 struct super_block *sb = root->sb;
2383
bd89aabc
PM
2384 cgrp = kzalloc(sizeof(*cgrp), GFP_KERNEL);
2385 if (!cgrp)
ddbcc7e8
PM
2386 return -ENOMEM;
2387
2388 /* Grab a reference on the superblock so the hierarchy doesn't
2389 * get deleted on unmount if there are child cgroups. This
2390 * can be done outside cgroup_mutex, since the sb can't
2391 * disappear while someone has an open control file on the
2392 * fs */
2393 atomic_inc(&sb->s_active);
2394
2395 mutex_lock(&cgroup_mutex);
2396
cc31edce 2397 init_cgroup_housekeeping(cgrp);
ddbcc7e8 2398
bd89aabc
PM
2399 cgrp->parent = parent;
2400 cgrp->root = parent->root;
2401 cgrp->top_cgroup = parent->top_cgroup;
ddbcc7e8 2402
b6abdb0e
LZ
2403 if (notify_on_release(parent))
2404 set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
2405
ddbcc7e8 2406 for_each_subsys(root, ss) {
bd89aabc 2407 struct cgroup_subsys_state *css = ss->create(ss, cgrp);
ddbcc7e8
PM
2408 if (IS_ERR(css)) {
2409 err = PTR_ERR(css);
2410 goto err_destroy;
2411 }
bd89aabc 2412 init_cgroup_css(css, ss, cgrp);
ddbcc7e8
PM
2413 }
2414
999cd8a4 2415 cgroup_lock_hierarchy(root);
bd89aabc 2416 list_add(&cgrp->sibling, &cgrp->parent->children);
999cd8a4 2417 cgroup_unlock_hierarchy(root);
ddbcc7e8
PM
2418 root->number_of_cgroups++;
2419
bd89aabc 2420 err = cgroup_create_dir(cgrp, dentry, mode);
ddbcc7e8
PM
2421 if (err < 0)
2422 goto err_remove;
2423
2424 /* The cgroup directory was pre-locked for us */
bd89aabc 2425 BUG_ON(!mutex_is_locked(&cgrp->dentry->d_inode->i_mutex));
ddbcc7e8 2426
bd89aabc 2427 err = cgroup_populate_dir(cgrp);
ddbcc7e8
PM
2428 /* If err < 0, we have a half-filled directory - oh well ;) */
2429
2430 mutex_unlock(&cgroup_mutex);
bd89aabc 2431 mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
ddbcc7e8
PM
2432
2433 return 0;
2434
2435 err_remove:
2436
bd89aabc 2437 list_del(&cgrp->sibling);
ddbcc7e8
PM
2438 root->number_of_cgroups--;
2439
2440 err_destroy:
2441
2442 for_each_subsys(root, ss) {
bd89aabc
PM
2443 if (cgrp->subsys[ss->subsys_id])
2444 ss->destroy(ss, cgrp);
ddbcc7e8
PM
2445 }
2446
2447 mutex_unlock(&cgroup_mutex);
2448
2449 /* Release the reference count that we took on the superblock */
2450 deactivate_super(sb);
2451
bd89aabc 2452 kfree(cgrp);
ddbcc7e8
PM
2453 return err;
2454}
2455
2456static int cgroup_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2457{
2458 struct cgroup *c_parent = dentry->d_parent->d_fsdata;
2459
2460 /* the vfs holds inode->i_mutex already */
2461 return cgroup_create(c_parent, dentry, mode | S_IFDIR);
2462}
2463
55b6fd01 2464static int cgroup_has_css_refs(struct cgroup *cgrp)
81a6a5cd
PM
2465{
2466 /* Check the reference count on each subsystem. Since we
2467 * already established that there are no tasks in the
e7c5ec91 2468 * cgroup, if the css refcount is also 1, then there should
81a6a5cd
PM
2469 * be no outstanding references, so the subsystem is safe to
2470 * destroy. We scan across all subsystems rather than using
2471 * the per-hierarchy linked list of mounted subsystems since
2472 * we can be called via check_for_release() with no
2473 * synchronization other than RCU, and the subsystem linked
2474 * list isn't RCU-safe */
2475 int i;
2476 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2477 struct cgroup_subsys *ss = subsys[i];
2478 struct cgroup_subsys_state *css;
2479 /* Skip subsystems not in this hierarchy */
bd89aabc 2480 if (ss->root != cgrp->root)
81a6a5cd 2481 continue;
bd89aabc 2482 css = cgrp->subsys[ss->subsys_id];
81a6a5cd
PM
2483 /* When called from check_for_release() it's possible
2484 * that by this point the cgroup has been removed
2485 * and the css deleted. But a false-positive doesn't
2486 * matter, since it can only happen if the cgroup
2487 * has been deleted and hence no longer needs the
2488 * release agent to be called anyway. */
e7c5ec91 2489 if (css && (atomic_read(&css->refcnt) > 1))
81a6a5cd 2490 return 1;
81a6a5cd
PM
2491 }
2492 return 0;
2493}
2494
e7c5ec91
PM
2495/*
2496 * Atomically mark all (or else none) of the cgroup's CSS objects as
2497 * CSS_REMOVED. Return true on success, or false if the cgroup has
2498 * busy subsystems. Call with cgroup_mutex held
2499 */
2500
2501static int cgroup_clear_css_refs(struct cgroup *cgrp)
2502{
2503 struct cgroup_subsys *ss;
2504 unsigned long flags;
2505 bool failed = false;
2506 local_irq_save(flags);
2507 for_each_subsys(cgrp->root, ss) {
2508 struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
2509 int refcnt;
2510 do {
2511 /* We can only remove a CSS with a refcnt==1 */
2512 refcnt = atomic_read(&css->refcnt);
2513 if (refcnt > 1) {
2514 failed = true;
2515 goto done;
2516 }
2517 BUG_ON(!refcnt);
2518 /*
2519 * Drop the refcnt to 0 while we check other
2520 * subsystems. This will cause any racing
2521 * css_tryget() to spin until we set the
2522 * CSS_REMOVED bits or abort
2523 */
2524 } while (atomic_cmpxchg(&css->refcnt, refcnt, 0) != refcnt);
2525 }
2526 done:
2527 for_each_subsys(cgrp->root, ss) {
2528 struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
2529 if (failed) {
2530 /*
2531 * Restore old refcnt if we previously managed
2532 * to clear it from 1 to 0
2533 */
2534 if (!atomic_read(&css->refcnt))
2535 atomic_set(&css->refcnt, 1);
2536 } else {
2537 /* Commit the fact that the CSS is removed */
2538 set_bit(CSS_REMOVED, &css->flags);
2539 }
2540 }
2541 local_irq_restore(flags);
2542 return !failed;
2543}
2544
ddbcc7e8
PM
2545static int cgroup_rmdir(struct inode *unused_dir, struct dentry *dentry)
2546{
bd89aabc 2547 struct cgroup *cgrp = dentry->d_fsdata;
ddbcc7e8
PM
2548 struct dentry *d;
2549 struct cgroup *parent;
ddbcc7e8
PM
2550
2551 /* the vfs holds both inode->i_mutex already */
2552
2553 mutex_lock(&cgroup_mutex);
bd89aabc 2554 if (atomic_read(&cgrp->count) != 0) {
ddbcc7e8
PM
2555 mutex_unlock(&cgroup_mutex);
2556 return -EBUSY;
2557 }
bd89aabc 2558 if (!list_empty(&cgrp->children)) {
ddbcc7e8
PM
2559 mutex_unlock(&cgroup_mutex);
2560 return -EBUSY;
2561 }
3fa59dfb 2562 mutex_unlock(&cgroup_mutex);
a043e3b2 2563
4fca88c8 2564 /*
a043e3b2
LZ
2565 * Call pre_destroy handlers of subsys. Notify subsystems
2566 * that rmdir() request comes.
4fca88c8
KH
2567 */
2568 cgroup_call_pre_destroy(cgrp);
ddbcc7e8 2569
3fa59dfb
KH
2570 mutex_lock(&cgroup_mutex);
2571 parent = cgrp->parent;
3fa59dfb
KH
2572
2573 if (atomic_read(&cgrp->count)
2574 || !list_empty(&cgrp->children)
e7c5ec91 2575 || !cgroup_clear_css_refs(cgrp)) {
ddbcc7e8
PM
2576 mutex_unlock(&cgroup_mutex);
2577 return -EBUSY;
2578 }
2579
81a6a5cd 2580 spin_lock(&release_list_lock);
bd89aabc
PM
2581 set_bit(CGRP_REMOVED, &cgrp->flags);
2582 if (!list_empty(&cgrp->release_list))
2583 list_del(&cgrp->release_list);
81a6a5cd 2584 spin_unlock(&release_list_lock);
999cd8a4
PM
2585
2586 cgroup_lock_hierarchy(cgrp->root);
2587 /* delete this cgroup from parent->children */
bd89aabc 2588 list_del(&cgrp->sibling);
999cd8a4
PM
2589 cgroup_unlock_hierarchy(cgrp->root);
2590
bd89aabc
PM
2591 spin_lock(&cgrp->dentry->d_lock);
2592 d = dget(cgrp->dentry);
ddbcc7e8
PM
2593 spin_unlock(&d->d_lock);
2594
2595 cgroup_d_remove_dir(d);
2596 dput(d);
ddbcc7e8 2597
bd89aabc 2598 set_bit(CGRP_RELEASABLE, &parent->flags);
81a6a5cd
PM
2599 check_for_release(parent);
2600
ddbcc7e8 2601 mutex_unlock(&cgroup_mutex);
ddbcc7e8
PM
2602 return 0;
2603}
2604
06a11920 2605static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
ddbcc7e8 2606{
ddbcc7e8 2607 struct cgroup_subsys_state *css;
cfe36bde
DC
2608
2609 printk(KERN_INFO "Initializing cgroup subsys %s\n", ss->name);
ddbcc7e8
PM
2610
2611 /* Create the top cgroup state for this subsystem */
33a68ac1 2612 list_add(&ss->sibling, &rootnode.subsys_list);
ddbcc7e8
PM
2613 ss->root = &rootnode;
2614 css = ss->create(ss, dummytop);
2615 /* We don't handle early failures gracefully */
2616 BUG_ON(IS_ERR(css));
2617 init_cgroup_css(css, ss, dummytop);
2618
e8d55fde 2619 /* Update the init_css_set to contain a subsys
817929ec 2620 * pointer to this state - since the subsystem is
e8d55fde
LZ
2621 * newly registered, all tasks and hence the
2622 * init_css_set is in the subsystem's top cgroup. */
2623 init_css_set.subsys[ss->subsys_id] = dummytop->subsys[ss->subsys_id];
ddbcc7e8
PM
2624
2625 need_forkexit_callback |= ss->fork || ss->exit;
2626
e8d55fde
LZ
2627 /* At system boot, before all subsystems have been
2628 * registered, no tasks have been forked, so we don't
2629 * need to invoke fork callbacks here. */
2630 BUG_ON(!list_empty(&init_task.tasks));
2631
999cd8a4 2632 mutex_init(&ss->hierarchy_mutex);
ddbcc7e8
PM
2633 ss->active = 1;
2634}
2635
2636/**
a043e3b2
LZ
2637 * cgroup_init_early - cgroup initialization at system boot
2638 *
2639 * Initialize cgroups at system boot, and initialize any
2640 * subsystems that request early init.
ddbcc7e8
PM
2641 */
2642int __init cgroup_init_early(void)
2643{
2644 int i;
146aa1bd 2645 atomic_set(&init_css_set.refcount, 1);
817929ec
PM
2646 INIT_LIST_HEAD(&init_css_set.cg_links);
2647 INIT_LIST_HEAD(&init_css_set.tasks);
472b1053 2648 INIT_HLIST_NODE(&init_css_set.hlist);
817929ec 2649 css_set_count = 1;
ddbcc7e8 2650 init_cgroup_root(&rootnode);
817929ec
PM
2651 root_count = 1;
2652 init_task.cgroups = &init_css_set;
2653
2654 init_css_set_link.cg = &init_css_set;
bd89aabc 2655 list_add(&init_css_set_link.cgrp_link_list,
817929ec
PM
2656 &rootnode.top_cgroup.css_sets);
2657 list_add(&init_css_set_link.cg_link_list,
2658 &init_css_set.cg_links);
ddbcc7e8 2659
472b1053
LZ
2660 for (i = 0; i < CSS_SET_TABLE_SIZE; i++)
2661 INIT_HLIST_HEAD(&css_set_table[i]);
2662
ddbcc7e8
PM
2663 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2664 struct cgroup_subsys *ss = subsys[i];
2665
2666 BUG_ON(!ss->name);
2667 BUG_ON(strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN);
2668 BUG_ON(!ss->create);
2669 BUG_ON(!ss->destroy);
2670 if (ss->subsys_id != i) {
cfe36bde 2671 printk(KERN_ERR "cgroup: Subsys %s id == %d\n",
ddbcc7e8
PM
2672 ss->name, ss->subsys_id);
2673 BUG();
2674 }
2675
2676 if (ss->early_init)
2677 cgroup_init_subsys(ss);
2678 }
2679 return 0;
2680}
2681
2682/**
a043e3b2
LZ
2683 * cgroup_init - cgroup initialization
2684 *
2685 * Register cgroup filesystem and /proc file, and initialize
2686 * any subsystems that didn't request early init.
ddbcc7e8
PM
2687 */
2688int __init cgroup_init(void)
2689{
2690 int err;
2691 int i;
472b1053 2692 struct hlist_head *hhead;
a424316c
PM
2693
2694 err = bdi_init(&cgroup_backing_dev_info);
2695 if (err)
2696 return err;
ddbcc7e8
PM
2697
2698 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2699 struct cgroup_subsys *ss = subsys[i];
2700 if (!ss->early_init)
2701 cgroup_init_subsys(ss);
2702 }
2703
472b1053
LZ
2704 /* Add init_css_set to the hash table */
2705 hhead = css_set_hash(init_css_set.subsys);
2706 hlist_add_head(&init_css_set.hlist, hhead);
2707
ddbcc7e8
PM
2708 err = register_filesystem(&cgroup_fs_type);
2709 if (err < 0)
2710 goto out;
2711
46ae220b 2712 proc_create("cgroups", 0, NULL, &proc_cgroupstats_operations);
a424316c 2713
ddbcc7e8 2714out:
a424316c
PM
2715 if (err)
2716 bdi_destroy(&cgroup_backing_dev_info);
2717
ddbcc7e8
PM
2718 return err;
2719}
b4f48b63 2720
a424316c
PM
2721/*
2722 * proc_cgroup_show()
2723 * - Print task's cgroup paths into seq_file, one line for each hierarchy
2724 * - Used for /proc/<pid>/cgroup.
2725 * - No need to task_lock(tsk) on this tsk->cgroup reference, as it
2726 * doesn't really matter if tsk->cgroup changes after we read it,
956db3ca 2727 * and we take cgroup_mutex, keeping cgroup_attach_task() from changing it
a424316c
PM
2728 * anyway. No need to check that tsk->cgroup != NULL, thanks to
2729 * the_top_cgroup_hack in cgroup_exit(), which sets an exiting tasks
2730 * cgroup to top_cgroup.
2731 */
2732
2733/* TODO: Use a proper seq_file iterator */
2734static int proc_cgroup_show(struct seq_file *m, void *v)
2735{
2736 struct pid *pid;
2737 struct task_struct *tsk;
2738 char *buf;
2739 int retval;
2740 struct cgroupfs_root *root;
2741
2742 retval = -ENOMEM;
2743 buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
2744 if (!buf)
2745 goto out;
2746
2747 retval = -ESRCH;
2748 pid = m->private;
2749 tsk = get_pid_task(pid, PIDTYPE_PID);
2750 if (!tsk)
2751 goto out_free;
2752
2753 retval = 0;
2754
2755 mutex_lock(&cgroup_mutex);
2756
e5f6a860 2757 for_each_active_root(root) {
a424316c 2758 struct cgroup_subsys *ss;
bd89aabc 2759 struct cgroup *cgrp;
a424316c
PM
2760 int subsys_id;
2761 int count = 0;
2762
b6c3006d 2763 seq_printf(m, "%lu:", root->subsys_bits);
a424316c
PM
2764 for_each_subsys(root, ss)
2765 seq_printf(m, "%s%s", count++ ? "," : "", ss->name);
2766 seq_putc(m, ':');
2767 get_first_subsys(&root->top_cgroup, NULL, &subsys_id);
bd89aabc
PM
2768 cgrp = task_cgroup(tsk, subsys_id);
2769 retval = cgroup_path(cgrp, buf, PAGE_SIZE);
a424316c
PM
2770 if (retval < 0)
2771 goto out_unlock;
2772 seq_puts(m, buf);
2773 seq_putc(m, '\n');
2774 }
2775
2776out_unlock:
2777 mutex_unlock(&cgroup_mutex);
2778 put_task_struct(tsk);
2779out_free:
2780 kfree(buf);
2781out:
2782 return retval;
2783}
2784
2785static int cgroup_open(struct inode *inode, struct file *file)
2786{
2787 struct pid *pid = PROC_I(inode)->pid;
2788 return single_open(file, proc_cgroup_show, pid);
2789}
2790
2791struct file_operations proc_cgroup_operations = {
2792 .open = cgroup_open,
2793 .read = seq_read,
2794 .llseek = seq_lseek,
2795 .release = single_release,
2796};
2797
2798/* Display information about each subsystem and each hierarchy */
2799static int proc_cgroupstats_show(struct seq_file *m, void *v)
2800{
2801 int i;
a424316c 2802
8bab8dde 2803 seq_puts(m, "#subsys_name\thierarchy\tnum_cgroups\tenabled\n");
a424316c 2804 mutex_lock(&cgroup_mutex);
a424316c
PM
2805 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2806 struct cgroup_subsys *ss = subsys[i];
8bab8dde 2807 seq_printf(m, "%s\t%lu\t%d\t%d\n",
817929ec 2808 ss->name, ss->root->subsys_bits,
8bab8dde 2809 ss->root->number_of_cgroups, !ss->disabled);
a424316c
PM
2810 }
2811 mutex_unlock(&cgroup_mutex);
2812 return 0;
2813}
2814
2815static int cgroupstats_open(struct inode *inode, struct file *file)
2816{
9dce07f1 2817 return single_open(file, proc_cgroupstats_show, NULL);
a424316c
PM
2818}
2819
2820static struct file_operations proc_cgroupstats_operations = {
2821 .open = cgroupstats_open,
2822 .read = seq_read,
2823 .llseek = seq_lseek,
2824 .release = single_release,
2825};
2826
b4f48b63
PM
2827/**
2828 * cgroup_fork - attach newly forked task to its parents cgroup.
a043e3b2 2829 * @child: pointer to task_struct of forking parent process.
b4f48b63
PM
2830 *
2831 * Description: A task inherits its parent's cgroup at fork().
2832 *
2833 * A pointer to the shared css_set was automatically copied in
2834 * fork.c by dup_task_struct(). However, we ignore that copy, since
2835 * it was not made under the protection of RCU or cgroup_mutex, so
956db3ca 2836 * might no longer be a valid cgroup pointer. cgroup_attach_task() might
817929ec
PM
2837 * have already changed current->cgroups, allowing the previously
2838 * referenced cgroup group to be removed and freed.
b4f48b63
PM
2839 *
2840 * At the point that cgroup_fork() is called, 'current' is the parent
2841 * task, and the passed argument 'child' points to the child task.
2842 */
2843void cgroup_fork(struct task_struct *child)
2844{
817929ec
PM
2845 task_lock(current);
2846 child->cgroups = current->cgroups;
2847 get_css_set(child->cgroups);
2848 task_unlock(current);
2849 INIT_LIST_HEAD(&child->cg_list);
b4f48b63
PM
2850}
2851
2852/**
a043e3b2
LZ
2853 * cgroup_fork_callbacks - run fork callbacks
2854 * @child: the new task
2855 *
2856 * Called on a new task very soon before adding it to the
2857 * tasklist. No need to take any locks since no-one can
2858 * be operating on this task.
b4f48b63
PM
2859 */
2860void cgroup_fork_callbacks(struct task_struct *child)
2861{
2862 if (need_forkexit_callback) {
2863 int i;
2864 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2865 struct cgroup_subsys *ss = subsys[i];
2866 if (ss->fork)
2867 ss->fork(ss, child);
2868 }
2869 }
2870}
2871
817929ec 2872/**
a043e3b2
LZ
2873 * cgroup_post_fork - called on a new task after adding it to the task list
2874 * @child: the task in question
2875 *
2876 * Adds the task to the list running through its css_set if necessary.
2877 * Has to be after the task is visible on the task list in case we race
2878 * with the first call to cgroup_iter_start() - to guarantee that the
2879 * new task ends up on its list.
2880 */
817929ec
PM
2881void cgroup_post_fork(struct task_struct *child)
2882{
2883 if (use_task_css_set_links) {
2884 write_lock(&css_set_lock);
b12b533f 2885 task_lock(child);
817929ec
PM
2886 if (list_empty(&child->cg_list))
2887 list_add(&child->cg_list, &child->cgroups->tasks);
b12b533f 2888 task_unlock(child);
817929ec
PM
2889 write_unlock(&css_set_lock);
2890 }
2891}
b4f48b63
PM
2892/**
2893 * cgroup_exit - detach cgroup from exiting task
2894 * @tsk: pointer to task_struct of exiting process
a043e3b2 2895 * @run_callback: run exit callbacks?
b4f48b63
PM
2896 *
2897 * Description: Detach cgroup from @tsk and release it.
2898 *
2899 * Note that cgroups marked notify_on_release force every task in
2900 * them to take the global cgroup_mutex mutex when exiting.
2901 * This could impact scaling on very large systems. Be reluctant to
2902 * use notify_on_release cgroups where very high task exit scaling
2903 * is required on large systems.
2904 *
2905 * the_top_cgroup_hack:
2906 *
2907 * Set the exiting tasks cgroup to the root cgroup (top_cgroup).
2908 *
2909 * We call cgroup_exit() while the task is still competent to
2910 * handle notify_on_release(), then leave the task attached to the
2911 * root cgroup in each hierarchy for the remainder of its exit.
2912 *
2913 * To do this properly, we would increment the reference count on
2914 * top_cgroup, and near the very end of the kernel/exit.c do_exit()
2915 * code we would add a second cgroup function call, to drop that
2916 * reference. This would just create an unnecessary hot spot on
2917 * the top_cgroup reference count, to no avail.
2918 *
2919 * Normally, holding a reference to a cgroup without bumping its
2920 * count is unsafe. The cgroup could go away, or someone could
2921 * attach us to a different cgroup, decrementing the count on
2922 * the first cgroup that we never incremented. But in this case,
2923 * top_cgroup isn't going away, and either task has PF_EXITING set,
956db3ca
CW
2924 * which wards off any cgroup_attach_task() attempts, or task is a failed
2925 * fork, never visible to cgroup_attach_task.
b4f48b63
PM
2926 */
2927void cgroup_exit(struct task_struct *tsk, int run_callbacks)
2928{
2929 int i;
817929ec 2930 struct css_set *cg;
b4f48b63
PM
2931
2932 if (run_callbacks && need_forkexit_callback) {
2933 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
2934 struct cgroup_subsys *ss = subsys[i];
2935 if (ss->exit)
2936 ss->exit(ss, tsk);
2937 }
2938 }
817929ec
PM
2939
2940 /*
2941 * Unlink from the css_set task list if necessary.
2942 * Optimistically check cg_list before taking
2943 * css_set_lock
2944 */
2945 if (!list_empty(&tsk->cg_list)) {
2946 write_lock(&css_set_lock);
2947 if (!list_empty(&tsk->cg_list))
2948 list_del(&tsk->cg_list);
2949 write_unlock(&css_set_lock);
2950 }
2951
b4f48b63
PM
2952 /* Reassign the task to the init_css_set. */
2953 task_lock(tsk);
817929ec
PM
2954 cg = tsk->cgroups;
2955 tsk->cgroups = &init_css_set;
b4f48b63 2956 task_unlock(tsk);
817929ec 2957 if (cg)
81a6a5cd 2958 put_css_set_taskexit(cg);
b4f48b63 2959}
697f4161
PM
2960
2961/**
a043e3b2
LZ
2962 * cgroup_clone - clone the cgroup the given subsystem is attached to
2963 * @tsk: the task to be moved
2964 * @subsys: the given subsystem
e885dcde 2965 * @nodename: the name for the new cgroup
a043e3b2
LZ
2966 *
2967 * Duplicate the current cgroup in the hierarchy that the given
2968 * subsystem is attached to, and move this task into the new
2969 * child.
697f4161 2970 */
e885dcde
SH
2971int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
2972 char *nodename)
697f4161
PM
2973{
2974 struct dentry *dentry;
2975 int ret = 0;
697f4161
PM
2976 struct cgroup *parent, *child;
2977 struct inode *inode;
2978 struct css_set *cg;
2979 struct cgroupfs_root *root;
2980 struct cgroup_subsys *ss;
2981
2982 /* We shouldn't be called by an unregistered subsystem */
2983 BUG_ON(!subsys->active);
2984
2985 /* First figure out what hierarchy and cgroup we're dealing
2986 * with, and pin them so we can drop cgroup_mutex */
2987 mutex_lock(&cgroup_mutex);
2988 again:
2989 root = subsys->root;
2990 if (root == &rootnode) {
697f4161
PM
2991 mutex_unlock(&cgroup_mutex);
2992 return 0;
2993 }
104cbd55 2994 task_lock(tsk);
817929ec 2995 cg = tsk->cgroups;
697f4161
PM
2996 parent = task_cgroup(tsk, subsys->subsys_id);
2997
697f4161 2998 /* Pin the hierarchy */
7b574b7b
LZ
2999 if (!atomic_inc_not_zero(&parent->root->sb->s_active)) {
3000 /* We race with the final deactivate_super() */
3001 mutex_unlock(&cgroup_mutex);
3002 return 0;
3003 }
697f4161 3004
817929ec
PM
3005 /* Keep the cgroup alive */
3006 get_css_set(cg);
104cbd55 3007 task_unlock(tsk);
697f4161
PM
3008 mutex_unlock(&cgroup_mutex);
3009
3010 /* Now do the VFS work to create a cgroup */
3011 inode = parent->dentry->d_inode;
3012
3013 /* Hold the parent directory mutex across this operation to
3014 * stop anyone else deleting the new cgroup */
3015 mutex_lock(&inode->i_mutex);
3016 dentry = lookup_one_len(nodename, parent->dentry, strlen(nodename));
3017 if (IS_ERR(dentry)) {
3018 printk(KERN_INFO
cfe36bde 3019 "cgroup: Couldn't allocate dentry for %s: %ld\n", nodename,
697f4161
PM
3020 PTR_ERR(dentry));
3021 ret = PTR_ERR(dentry);
3022 goto out_release;
3023 }
3024
3025 /* Create the cgroup directory, which also creates the cgroup */
75139b82 3026 ret = vfs_mkdir(inode, dentry, 0755);
bd89aabc 3027 child = __d_cgrp(dentry);
697f4161
PM
3028 dput(dentry);
3029 if (ret) {
3030 printk(KERN_INFO
3031 "Failed to create cgroup %s: %d\n", nodename,
3032 ret);
3033 goto out_release;
3034 }
3035
697f4161
PM
3036 /* The cgroup now exists. Retake cgroup_mutex and check
3037 * that we're still in the same state that we thought we
3038 * were. */
3039 mutex_lock(&cgroup_mutex);
3040 if ((root != subsys->root) ||
3041 (parent != task_cgroup(tsk, subsys->subsys_id))) {
3042 /* Aargh, we raced ... */
3043 mutex_unlock(&inode->i_mutex);
817929ec 3044 put_css_set(cg);
697f4161
PM
3045
3046 deactivate_super(parent->root->sb);
3047 /* The cgroup is still accessible in the VFS, but
3048 * we're not going to try to rmdir() it at this
3049 * point. */
3050 printk(KERN_INFO
3051 "Race in cgroup_clone() - leaking cgroup %s\n",
3052 nodename);
3053 goto again;
3054 }
3055
3056 /* do any required auto-setup */
3057 for_each_subsys(root, ss) {
3058 if (ss->post_clone)
3059 ss->post_clone(ss, child);
3060 }
3061
3062 /* All seems fine. Finish by moving the task into the new cgroup */
956db3ca 3063 ret = cgroup_attach_task(child, tsk);
697f4161
PM
3064 mutex_unlock(&cgroup_mutex);
3065
3066 out_release:
3067 mutex_unlock(&inode->i_mutex);
81a6a5cd
PM
3068
3069 mutex_lock(&cgroup_mutex);
817929ec 3070 put_css_set(cg);
81a6a5cd 3071 mutex_unlock(&cgroup_mutex);
697f4161
PM
3072 deactivate_super(parent->root->sb);
3073 return ret;
3074}
3075
a043e3b2
LZ
3076/**
3077 * cgroup_is_descendant - see if @cgrp is a descendant of current task's cgrp
3078 * @cgrp: the cgroup in question
3079 *
3080 * See if @cgrp is a descendant of the current task's cgroup in
3081 * the appropriate hierarchy.
697f4161
PM
3082 *
3083 * If we are sending in dummytop, then presumably we are creating
3084 * the top cgroup in the subsystem.
3085 *
3086 * Called only by the ns (nsproxy) cgroup.
3087 */
bd89aabc 3088int cgroup_is_descendant(const struct cgroup *cgrp)
697f4161
PM
3089{
3090 int ret;
3091 struct cgroup *target;
3092 int subsys_id;
3093
bd89aabc 3094 if (cgrp == dummytop)
697f4161
PM
3095 return 1;
3096
bd89aabc 3097 get_first_subsys(cgrp, NULL, &subsys_id);
697f4161 3098 target = task_cgroup(current, subsys_id);
bd89aabc
PM
3099 while (cgrp != target && cgrp!= cgrp->top_cgroup)
3100 cgrp = cgrp->parent;
3101 ret = (cgrp == target);
697f4161
PM
3102 return ret;
3103}
81a6a5cd 3104
bd89aabc 3105static void check_for_release(struct cgroup *cgrp)
81a6a5cd
PM
3106{
3107 /* All of these checks rely on RCU to keep the cgroup
3108 * structure alive */
bd89aabc
PM
3109 if (cgroup_is_releasable(cgrp) && !atomic_read(&cgrp->count)
3110 && list_empty(&cgrp->children) && !cgroup_has_css_refs(cgrp)) {
81a6a5cd
PM
3111 /* Control Group is currently removeable. If it's not
3112 * already queued for a userspace notification, queue
3113 * it now */
3114 int need_schedule_work = 0;
3115 spin_lock(&release_list_lock);
bd89aabc
PM
3116 if (!cgroup_is_removed(cgrp) &&
3117 list_empty(&cgrp->release_list)) {
3118 list_add(&cgrp->release_list, &release_list);
81a6a5cd
PM
3119 need_schedule_work = 1;
3120 }
3121 spin_unlock(&release_list_lock);
3122 if (need_schedule_work)
3123 schedule_work(&release_agent_work);
3124 }
3125}
3126
3127void __css_put(struct cgroup_subsys_state *css)
3128{
bd89aabc 3129 struct cgroup *cgrp = css->cgroup;
81a6a5cd 3130 rcu_read_lock();
e7c5ec91
PM
3131 if ((atomic_dec_return(&css->refcnt) == 1) &&
3132 notify_on_release(cgrp)) {
bd89aabc
PM
3133 set_bit(CGRP_RELEASABLE, &cgrp->flags);
3134 check_for_release(cgrp);
81a6a5cd
PM
3135 }
3136 rcu_read_unlock();
3137}
3138
3139/*
3140 * Notify userspace when a cgroup is released, by running the
3141 * configured release agent with the name of the cgroup (path
3142 * relative to the root of cgroup file system) as the argument.
3143 *
3144 * Most likely, this user command will try to rmdir this cgroup.
3145 *
3146 * This races with the possibility that some other task will be
3147 * attached to this cgroup before it is removed, or that some other
3148 * user task will 'mkdir' a child cgroup of this cgroup. That's ok.
3149 * The presumed 'rmdir' will fail quietly if this cgroup is no longer
3150 * unused, and this cgroup will be reprieved from its death sentence,
3151 * to continue to serve a useful existence. Next time it's released,
3152 * we will get notified again, if it still has 'notify_on_release' set.
3153 *
3154 * The final arg to call_usermodehelper() is UMH_WAIT_EXEC, which
3155 * means only wait until the task is successfully execve()'d. The
3156 * separate release agent task is forked by call_usermodehelper(),
3157 * then control in this thread returns here, without waiting for the
3158 * release agent task. We don't bother to wait because the caller of
3159 * this routine has no use for the exit status of the release agent
3160 * task, so no sense holding our caller up for that.
81a6a5cd 3161 */
81a6a5cd
PM
3162static void cgroup_release_agent(struct work_struct *work)
3163{
3164 BUG_ON(work != &release_agent_work);
3165 mutex_lock(&cgroup_mutex);
3166 spin_lock(&release_list_lock);
3167 while (!list_empty(&release_list)) {
3168 char *argv[3], *envp[3];
3169 int i;
e788e066 3170 char *pathbuf = NULL, *agentbuf = NULL;
bd89aabc 3171 struct cgroup *cgrp = list_entry(release_list.next,
81a6a5cd
PM
3172 struct cgroup,
3173 release_list);
bd89aabc 3174 list_del_init(&cgrp->release_list);
81a6a5cd
PM
3175 spin_unlock(&release_list_lock);
3176 pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
e788e066
PM
3177 if (!pathbuf)
3178 goto continue_free;
3179 if (cgroup_path(cgrp, pathbuf, PAGE_SIZE) < 0)
3180 goto continue_free;
3181 agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL);
3182 if (!agentbuf)
3183 goto continue_free;
81a6a5cd
PM
3184
3185 i = 0;
e788e066
PM
3186 argv[i++] = agentbuf;
3187 argv[i++] = pathbuf;
81a6a5cd
PM
3188 argv[i] = NULL;
3189
3190 i = 0;
3191 /* minimal command environment */
3192 envp[i++] = "HOME=/";
3193 envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
3194 envp[i] = NULL;
3195
3196 /* Drop the lock while we invoke the usermode helper,
3197 * since the exec could involve hitting disk and hence
3198 * be a slow process */
3199 mutex_unlock(&cgroup_mutex);
3200 call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
81a6a5cd 3201 mutex_lock(&cgroup_mutex);
e788e066
PM
3202 continue_free:
3203 kfree(pathbuf);
3204 kfree(agentbuf);
81a6a5cd
PM
3205 spin_lock(&release_list_lock);
3206 }
3207 spin_unlock(&release_list_lock);
3208 mutex_unlock(&cgroup_mutex);
3209}
8bab8dde
PM
3210
3211static int __init cgroup_disable(char *str)
3212{
3213 int i;
3214 char *token;
3215
3216 while ((token = strsep(&str, ",")) != NULL) {
3217 if (!*token)
3218 continue;
3219
3220 for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
3221 struct cgroup_subsys *ss = subsys[i];
3222
3223 if (!strcmp(token, ss->name)) {
3224 ss->disabled = 1;
3225 printk(KERN_INFO "Disabling %s control group"
3226 " subsystem\n", ss->name);
3227 break;
3228 }
3229 }
3230 }
3231 return 1;
3232}
3233__setup("cgroup_disable=", cgroup_disable);