linux - kernel/cgroup.c

3050 lines · 79.2 KiB

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