Kernel

Kernel Git Source Tree

Root/kernel/cgroup.c

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	* Notifications support
8	* Copyright (C) 2009 Nokia Corporation
9	* Author: Kirill A. Shutemov
10	*
11	* Copyright notices from the original cpuset code:
12	* --------------------------------------------------
13	* Copyright (C) 2003 BULL SA.
14	* Copyright (C) 2004-2006 Silicon Graphics, Inc.
15	*
16	* Portions derived from Patrick Mochel's sysfs code.
17	* sysfs is Copyright (c) 2001-3 Patrick Mochel
18	*
19	* 2003-10-10 Written by Simon Derr.
20	* 2003-10-22 Updates by Stephen Hemminger.
21	* 2004 May-July Rework by Paul Jackson.
22	* ---------------------------------------------------
23	*
24	* This file is subject to the terms and conditions of the GNU General Public
25	* License. See the file COPYING in the main directory of the Linux
26	* distribution for more details.
27	*/
28
29	#include <linux/cgroup.h>
30	#include <linux/ctype.h>
31	#include <linux/errno.h>
32	#include <linux/fs.h>
33	#include <linux/kernel.h>
34	#include <linux/list.h>
35	#include <linux/mm.h>
36	#include <linux/mutex.h>
37	#include <linux/mount.h>
38	#include <linux/pagemap.h>
39	#include <linux/proc_fs.h>
40	#include <linux/rcupdate.h>
41	#include <linux/sched.h>
42	#include <linux/backing-dev.h>
43	#include <linux/seq_file.h>
44	#include <linux/slab.h>
45	#include <linux/magic.h>
46	#include <linux/spinlock.h>
47	#include <linux/string.h>
48	#include <linux/sort.h>
49	#include <linux/kmod.h>
50	#include <linux/module.h>
51	#include <linux/delayacct.h>
52	#include <linux/cgroupstats.h>
53	#include <linux/hash.h>
54	#include <linux/namei.h>
55	#include <linux/smp_lock.h>
56	#include <linux/pid_namespace.h>
57	#include <linux/idr.h>
58	#include <linux/vmalloc.h> /* TODO: replace with more sophisticated array */
59	#include <linux/eventfd.h>
60	#include <linux/poll.h>
61
62	#include <asm/atomic.h>
63
64	static DEFINE_MUTEX(cgroup_mutex);
65
66	/*
67	* Generate an array of cgroup subsystem pointers. At boot time, this is
68	* populated up to CGROUP_BUILTIN_SUBSYS_COUNT, and modular subsystems are
69	* registered after that. The mutable section of this array is protected by
70	* cgroup_mutex.
71	*/
72	#define SUBSYS(_x) &_x ## _subsys,
73	static struct cgroup_subsys *subsys[CGROUP_SUBSYS_COUNT] = {
74	#include <linux/cgroup_subsys.h>
75	};
76
77	#define MAX_CGROUP_ROOT_NAMELEN 64
78
79	/*
80	* A cgroupfs_root represents the root of a cgroup hierarchy,
81	* and may be associated with a superblock to form an active
82	* hierarchy
83	*/
84	struct cgroupfs_root {
85	struct super_block *sb;
86
87	/*
88	* The bitmask of subsystems intended to be attached to this
89	* hierarchy
90	*/
91	unsigned long subsys_bits;
92
93	/* Unique id for this hierarchy. */
94	int hierarchy_id;
95
96	/* The bitmask of subsystems currently attached to this hierarchy */
97	unsigned long actual_subsys_bits;
98
99	/* A list running through the attached subsystems */
100	struct list_head subsys_list;
101
102	/* The root cgroup for this hierarchy */
103	struct cgroup top_cgroup;
104
105	/* Tracks how many cgroups are currently defined in hierarchy.*/
106	int number_of_cgroups;
107
108	/* A list running through the active hierarchies */
109	struct list_head root_list;
110
111	/* Hierarchy-specific flags */
112	unsigned long flags;
113
114	/* The path to use for release notifications. */
115	char release_agent_path[PATH_MAX];
116
117	/* The name for this hierarchy - may be empty */
118	char name[MAX_CGROUP_ROOT_NAMELEN];
119	};
120
121	/*
122	* The "rootnode" hierarchy is the "dummy hierarchy", reserved for the
123	* subsystems that are otherwise unattached - it never has more than a
124	* single cgroup, and all tasks are part of that cgroup.
125	*/
126	static struct cgroupfs_root rootnode;
127
128	/*
129	* CSS ID -- ID per subsys's Cgroup Subsys State(CSS). used only when
130	* cgroup_subsys->use_id != 0.
131	*/
132	#define CSS_ID_MAX (65535)
133	struct css_id {
134	/*
135	* The css to which this ID points. This pointer is set to valid value
136	* after cgroup is populated. If cgroup is removed, this will be NULL.
137	* This pointer is expected to be RCU-safe because destroy()
138	* is called after synchronize_rcu(). But for safe use, css_is_removed()
139	* css_tryget() should be used for avoiding race.
140	*/
141	struct cgroup_subsys_state *css;
142	/*
143	* ID of this css.
144	*/
145	unsigned short id;
146	/*
147	* Depth in hierarchy which this ID belongs to.
148	*/
149	unsigned short depth;
150	/*
151	* ID is freed by RCU. (and lookup routine is RCU safe.)
152	*/
153	struct rcu_head rcu_head;
154	/*
155	* Hierarchy of CSS ID belongs to.
156	*/
157	unsigned short stack[0]; /* Array of Length (depth+1) */
158	};
159
160	/*
161	* cgroup_event represents events which userspace want to recieve.
162	*/
163	struct cgroup_event {
164	/*
165	* Cgroup which the event belongs to.
166	*/
167	struct cgroup *cgrp;
168	/*
169	* Control file which the event associated.
170	*/
171	struct cftype *cft;
172	/*
173	* eventfd to signal userspace about the event.
174	*/
175	struct eventfd_ctx *eventfd;
176	/*
177	* Each of these stored in a list by the cgroup.
178	*/
179	struct list_head list;
180	/*
181	* All fields below needed to unregister event when
182	* userspace closes eventfd.
183	*/
184	poll_table pt;
185	wait_queue_head_t *wqh;
186	wait_queue_t wait;
187	struct work_struct remove;
188	};
189
190	/* The list of hierarchy roots */
191
192	static LIST_HEAD(roots);
193	static int root_count;
194
195	static DEFINE_IDA(hierarchy_ida);
196	static int next_hierarchy_id;
197	static DEFINE_SPINLOCK(hierarchy_id_lock);
198
199	/* dummytop is a shorthand for the dummy hierarchy's top cgroup */
200	#define dummytop (&rootnode.top_cgroup)
201
202	/* This flag indicates whether tasks in the fork and exit paths should
203	* check for fork/exit handlers to call. This avoids us having to do
204	* extra work in the fork/exit path if none of the subsystems need to
205	* be called.
206	*/
207	static int need_forkexit_callback __read_mostly;
208
209	#ifdef CONFIG_PROVE_LOCKING
210	int cgroup_lock_is_held(void)
211	{
212	return lockdep_is_held(&cgroup_mutex);
213	}
214	#else /* #ifdef CONFIG_PROVE_LOCKING */
215	int cgroup_lock_is_held(void)
216	{
217	return mutex_is_locked(&cgroup_mutex);
218	}
219	#endif /* #else #ifdef CONFIG_PROVE_LOCKING */
220
221	EXPORT_SYMBOL_GPL(cgroup_lock_is_held);
222
223	/* convenient tests for these bits */
224	inline int cgroup_is_removed(const struct cgroup *cgrp)
225	{
226	return test_bit(CGRP_REMOVED, &cgrp->flags);
227	}
228
229	/* bits in struct cgroupfs_root flags field */
230	enum {
231	ROOT_NOPREFIX, /* mounted subsystems have no named prefix */
232	};
233
234	static int cgroup_is_releasable(const struct cgroup *cgrp)
235	{
236	const int bits =
237	(1 << CGRP_RELEASABLE) \|
238	(1 << CGRP_NOTIFY_ON_RELEASE);
239	return (cgrp->flags & bits) == bits;
240	}
241
242	static int notify_on_release(const struct cgroup *cgrp)
243	{
244	return test_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
245	}
246
247	/*
248	* for_each_subsys() allows you to iterate on each subsystem attached to
249	* an active hierarchy
250	*/
251	#define for_each_subsys(_root, _ss) \
252	list_for_each_entry(_ss, &_root->subsys_list, sibling)
253
254	/* for_each_active_root() allows you to iterate across the active hierarchies */
255	#define for_each_active_root(_root) \
256	list_for_each_entry(_root, &roots, root_list)
257
258	/* the list of cgroups eligible for automatic release. Protected by
259	* release_list_lock */
260	static LIST_HEAD(release_list);
261	static DEFINE_SPINLOCK(release_list_lock);
262	static void cgroup_release_agent(struct work_struct *work);
263	static DECLARE_WORK(release_agent_work, cgroup_release_agent);
264	static void check_for_release(struct cgroup *cgrp);
265
266	/* Link structure for associating css_set objects with cgroups */
267	struct cg_cgroup_link {
268	/*
269	* List running through cg_cgroup_links associated with a
270	* cgroup, anchored on cgroup->css_sets
271	*/
272	struct list_head cgrp_link_list;
273	struct cgroup *cgrp;
274	/*
275	* List running through cg_cgroup_links pointing at a
276	* single css_set object, anchored on css_set->cg_links
277	*/
278	struct list_head cg_link_list;
279	struct css_set *cg;
280	};
281
282	/* The default css_set - used by init and its children prior to any
283	* hierarchies being mounted. It contains a pointer to the root state
284	* for each subsystem. Also used to anchor the list of css_sets. Not
285	* reference-counted, to improve performance when child cgroups
286	* haven't been created.
287	*/
288
289	static struct css_set init_css_set;
290	static struct cg_cgroup_link init_css_set_link;
291
292	static int cgroup_init_idr(struct cgroup_subsys *ss,
293	struct cgroup_subsys_state *css);
294
295	/* css_set_lock protects the list of css_set objects, and the
296	* chain of tasks off each css_set. Nests outside task->alloc_lock
297	* due to cgroup_iter_start() */
298	static DEFINE_RWLOCK(css_set_lock);
299	static int css_set_count;
300
301	/*
302	* hash table for cgroup groups. This improves the performance to find
303	* an existing css_set. This hash doesn't (currently) take into
304	* account cgroups in empty hierarchies.
305	*/
306	#define CSS_SET_HASH_BITS 7
307	#define CSS_SET_TABLE_SIZE (1 << CSS_SET_HASH_BITS)
308	static struct hlist_head css_set_table[CSS_SET_TABLE_SIZE];
309
310	static struct hlist_head css_set_hash(struct cgroup_subsys_state css[])
311	{
312	int i;
313	int index;
314	unsigned long tmp = 0UL;
315
316	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++)
317	tmp += (unsigned long)css[i];
318	tmp = (tmp >> 16) ^ tmp;
319
320	index = hash_long(tmp, CSS_SET_HASH_BITS);
321
322	return &css_set_table[index];
323	}
324
325	static void free_css_set_rcu(struct rcu_head *obj)
326	{
327	struct css_set *cg = container_of(obj, struct css_set, rcu_head);
328	kfree(cg);
329	}
330
331	/* We don't maintain the lists running through each css_set to its
332	* task until after the first call to cgroup_iter_start(). This
333	* reduces the fork()/exit() overhead for people who have cgroups
334	* compiled into their kernel but not actually in use */
335	static int use_task_css_set_links __read_mostly;
336
337	static void __put_css_set(struct css_set *cg, int taskexit)
338	{
339	struct cg_cgroup_link *link;
340	struct cg_cgroup_link *saved_link;
341	/*
342	* Ensure that the refcount doesn't hit zero while any readers
343	* can see it. Similar to atomic_dec_and_lock(), but for an
344	* rwlock
345	*/
346	if (atomic_add_unless(&cg->refcount, -1, 1))
347	return;
348	write_lock(&css_set_lock);
349	if (!atomic_dec_and_test(&cg->refcount)) {
350	write_unlock(&css_set_lock);
351	return;
352	}
353
354	/* This css_set is dead. unlink it and release cgroup refcounts */
355	hlist_del(&cg->hlist);
356	css_set_count--;
357
358	list_for_each_entry_safe(link, saved_link, &cg->cg_links,
359	cg_link_list) {
360	struct cgroup *cgrp = link->cgrp;
361	list_del(&link->cg_link_list);
362	list_del(&link->cgrp_link_list);
363	if (atomic_dec_and_test(&cgrp->count) &&
364	notify_on_release(cgrp)) {
365	if (taskexit)
366	set_bit(CGRP_RELEASABLE, &cgrp->flags);
367	check_for_release(cgrp);
368	}
369
370	kfree(link);
371	}
372
373	write_unlock(&css_set_lock);
374	call_rcu(&cg->rcu_head, free_css_set_rcu);
375	}
376
377	/*
378	* refcounted get/put for css_set objects
379	*/
380	static inline void get_css_set(struct css_set *cg)
381	{
382	atomic_inc(&cg->refcount);
383	}
384
385	static inline void put_css_set(struct css_set *cg)
386	{
387	__put_css_set(cg, 0);
388	}
389
390	static inline void put_css_set_taskexit(struct css_set *cg)
391	{
392	__put_css_set(cg, 1);
393	}
394
395	/*
396	* compare_css_sets - helper function for find_existing_css_set().
397	* @cg: candidate css_set being tested
398	* @old_cg: existing css_set for a task
399	* @new_cgrp: cgroup that's being entered by the task
400	* @template: desired set of css pointers in css_set (pre-calculated)
401	*
402	* Returns true if "cg" matches "old_cg" except for the hierarchy
403	* which "new_cgrp" belongs to, for which it should match "new_cgrp".
404	*/
405	static bool compare_css_sets(struct css_set *cg,
406	struct css_set *old_cg,
407	struct cgroup *new_cgrp,
408	struct cgroup_subsys_state *template[])
409	{
410	struct list_head l1, l2;
411
412	if (memcmp(template, cg->subsys, sizeof(cg->subsys))) {
413	/* Not all subsystems matched */
414	return false;
415	}
416
417	/*
418	* Compare cgroup pointers in order to distinguish between
419	* different cgroups in heirarchies with no subsystems. We
420	* could get by with just this check alone (and skip the
421	* memcmp above) but on most setups the memcmp check will
422	* avoid the need for this more expensive check on almost all
423	* candidates.
424	*/
425
426	l1 = &cg->cg_links;
427	l2 = &old_cg->cg_links;
428	while (1) {
429	struct cg_cgroup_link cgl1, cgl2;
430	struct cgroup cg1, cg2;
431
432	l1 = l1->next;
433	l2 = l2->next;
434	/* See if we reached the end - both lists are equal length. */
435	if (l1 == &cg->cg_links) {
436	BUG_ON(l2 != &old_cg->cg_links);
437	break;
438	} else {
439	BUG_ON(l2 == &old_cg->cg_links);
440	}
441	/* Locate the cgroups associated with these links. */
442	cgl1 = list_entry(l1, struct cg_cgroup_link, cg_link_list);
443	cgl2 = list_entry(l2, struct cg_cgroup_link, cg_link_list);
444	cg1 = cgl1->cgrp;
445	cg2 = cgl2->cgrp;
446	/* Hierarchies should be linked in the same order. */
447	BUG_ON(cg1->root != cg2->root);
448
449	/*
450	* If this hierarchy is the hierarchy of the cgroup
451	* that's changing, then we need to check that this
452	* css_set points to the new cgroup; if it's any other
453	* hierarchy, then this css_set should point to the
454	* same cgroup as the old css_set.
455	*/
456	if (cg1->root == new_cgrp->root) {
457	if (cg1 != new_cgrp)
458	return false;
459	} else {
460	if (cg1 != cg2)
461	return false;
462	}
463	}
464	return true;
465	}
466
467	/*
468	* find_existing_css_set() is a helper for
469	* find_css_set(), and checks to see whether an existing
470	* css_set is suitable.
471	*
472	* oldcg: the cgroup group that we're using before the cgroup
473	* transition
474	*
475	* cgrp: the cgroup that we're moving into
476	*
477	* template: location in which to build the desired set of subsystem
478	* state objects for the new cgroup group
479	*/
480	static struct css_set *find_existing_css_set(
481	struct css_set *oldcg,
482	struct cgroup *cgrp,
483	struct cgroup_subsys_state *template[])
484	{
485	int i;
486	struct cgroupfs_root *root = cgrp->root;
487	struct hlist_head *hhead;
488	struct hlist_node *node;
489	struct css_set *cg;
490
491	/*
492	* Build the set of subsystem state objects that we want to see in the
493	* new css_set. while subsystems can change globally, the entries here
494	* won't change, so no need for locking.
495	*/
496	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
497	if (root->subsys_bits & (1UL << i)) {
498	/* Subsystem is in this hierarchy. So we want
499	* the subsystem state from the new
500	* cgroup */
501	template[i] = cgrp->subsys[i];
502	} else {
503	/* Subsystem is not in this hierarchy, so we
504	* don't want to change the subsystem state */
505	template[i] = oldcg->subsys[i];
506	}
507	}
508
509	hhead = css_set_hash(template);
510	hlist_for_each_entry(cg, node, hhead, hlist) {
511	if (!compare_css_sets(cg, oldcg, cgrp, template))
512	continue;
513
514	/* This css_set matches what we need */
515	return cg;
516	}
517
518	/* No existing cgroup group matched */
519	return NULL;
520	}
521
522	static void free_cg_links(struct list_head *tmp)
523	{
524	struct cg_cgroup_link *link;
525	struct cg_cgroup_link *saved_link;
526
527	list_for_each_entry_safe(link, saved_link, tmp, cgrp_link_list) {
528	list_del(&link->cgrp_link_list);
529	kfree(link);
530	}
531	}
532
533	/*
534	* allocate_cg_links() allocates "count" cg_cgroup_link structures
535	* and chains them on tmp through their cgrp_link_list fields. Returns 0 on
536	* success or a negative error
537	*/
538	static int allocate_cg_links(int count, struct list_head *tmp)
539	{
540	struct cg_cgroup_link *link;
541	int i;
542	INIT_LIST_HEAD(tmp);
543	for (i = 0; i < count; i++) {
544	link = kmalloc(sizeof(*link), GFP_KERNEL);
545	if (!link) {
546	free_cg_links(tmp);
547	return -ENOMEM;
548	}
549	list_add(&link->cgrp_link_list, tmp);
550	}
551	return 0;
552	}
553
554	/**
555	* link_css_set - a helper function to link a css_set to a cgroup
556	* @tmp_cg_links: cg_cgroup_link objects allocated by allocate_cg_links()
557	* @cg: the css_set to be linked
558	* @cgrp: the destination cgroup
559	*/
560	static void link_css_set(struct list_head *tmp_cg_links,
561	struct css_set cg, struct cgroup cgrp)
562	{
563	struct cg_cgroup_link *link;
564
565	BUG_ON(list_empty(tmp_cg_links));
566	link = list_first_entry(tmp_cg_links, struct cg_cgroup_link,
567	cgrp_link_list);
568	link->cg = cg;
569	link->cgrp = cgrp;
570	atomic_inc(&cgrp->count);
571	list_move(&link->cgrp_link_list, &cgrp->css_sets);
572	/*
573	* Always add links to the tail of the list so that the list
574	* is sorted by order of hierarchy creation
575	*/
576	list_add_tail(&link->cg_link_list, &cg->cg_links);
577	}
578
579	/*
580	* find_css_set() takes an existing cgroup group and a
581	* cgroup object, and returns a css_set object that's
582	* equivalent to the old group, but with the given cgroup
583	* substituted into the appropriate hierarchy. Must be called with
584	* cgroup_mutex held
585	*/
586	static struct css_set *find_css_set(
587	struct css_set oldcg, struct cgroup cgrp)
588	{
589	struct css_set *res;
590	struct cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT];
591
592	struct list_head tmp_cg_links;
593
594	struct hlist_head *hhead;
595	struct cg_cgroup_link *link;
596
597	/* First see if we already have a cgroup group that matches
598	* the desired set */
599	read_lock(&css_set_lock);
600	res = find_existing_css_set(oldcg, cgrp, template);
601	if (res)
602	get_css_set(res);
603	read_unlock(&css_set_lock);
604
605	if (res)
606	return res;
607
608	res = kmalloc(sizeof(*res), GFP_KERNEL);
609	if (!res)
610	return NULL;
611
612	/* Allocate all the cg_cgroup_link objects that we'll need */
613	if (allocate_cg_links(root_count, &tmp_cg_links) < 0) {
614	kfree(res);
615	return NULL;
616	}
617
618	atomic_set(&res->refcount, 1);
619	INIT_LIST_HEAD(&res->cg_links);
620	INIT_LIST_HEAD(&res->tasks);
621	INIT_HLIST_NODE(&res->hlist);
622
623	/* Copy the set of subsystem state objects generated in
624	* find_existing_css_set() */
625	memcpy(res->subsys, template, sizeof(res->subsys));
626
627	write_lock(&css_set_lock);
628	/* Add reference counts and links from the new css_set. */
629	list_for_each_entry(link, &oldcg->cg_links, cg_link_list) {
630	struct cgroup *c = link->cgrp;
631	if (c->root == cgrp->root)
632	c = cgrp;
633	link_css_set(&tmp_cg_links, res, c);
634	}
635
636	BUG_ON(!list_empty(&tmp_cg_links));
637
638	css_set_count++;
639
640	/* Add this cgroup group to the hash table */
641	hhead = css_set_hash(res->subsys);
642	hlist_add_head(&res->hlist, hhead);
643
644	write_unlock(&css_set_lock);
645
646	return res;
647	}
648
649	/*
650	* Return the cgroup for "task" from the given hierarchy. Must be
651	* called with cgroup_mutex held.
652	*/
653	static struct cgroup task_cgroup_from_root(struct task_struct task,
654	struct cgroupfs_root *root)
655	{
656	struct css_set *css;
657	struct cgroup *res = NULL;
658
659	BUG_ON(!mutex_is_locked(&cgroup_mutex));
660	read_lock(&css_set_lock);
661	/*
662	* No need to lock the task - since we hold cgroup_mutex the
663	* task can't change groups, so the only thing that can happen
664	* is that it exits and its css is set back to init_css_set.
665	*/
666	css = task->cgroups;
667	if (css == &init_css_set) {
668	res = &root->top_cgroup;
669	} else {
670	struct cg_cgroup_link *link;
671	list_for_each_entry(link, &css->cg_links, cg_link_list) {
672	struct cgroup *c = link->cgrp;
673	if (c->root == root) {
674	res = c;
675	break;
676	}
677	}
678	}
679	read_unlock(&css_set_lock);
680	BUG_ON(!res);
681	return res;
682	}
683
684	/*
685	* There is one global cgroup mutex. We also require taking
686	* task_lock() when dereferencing a task's cgroup subsys pointers.
687	* See "The task_lock() exception", at the end of this comment.
688	*
689	* A task must hold cgroup_mutex to modify cgroups.
690	*
691	* Any task can increment and decrement the count field without lock.
692	* So in general, code holding cgroup_mutex can't rely on the count
693	* field not changing. However, if the count goes to zero, then only
694	* cgroup_attach_task() can increment it again. Because a count of zero
695	* means that no tasks are currently attached, therefore there is no
696	* way a task attached to that cgroup can fork (the other way to
697	* increment the count). So code holding cgroup_mutex can safely
698	* assume that if the count is zero, it will stay zero. Similarly, if
699	* a task holds cgroup_mutex on a cgroup with zero count, it
700	* knows that the cgroup won't be removed, as cgroup_rmdir()
701	* needs that mutex.
702	*
703	* The fork and exit callbacks cgroup_fork() and cgroup_exit(), don't
704	* (usually) take cgroup_mutex. These are the two most performance
705	* critical pieces of code here. The exception occurs on cgroup_exit(),
706	* when a task in a notify_on_release cgroup exits. Then cgroup_mutex
707	* is taken, and if the cgroup count is zero, a usermode call made
708	* to the release agent with the name of the cgroup (path relative to
709	* the root of cgroup file system) as the argument.
710	*
711	* A cgroup can only be deleted if both its 'count' of using tasks
712	* is zero, and its list of 'children' cgroups is empty. Since all
713	* tasks in the system use _some_ cgroup, and since there is always at
714	* least one task in the system (init, pid == 1), therefore, top_cgroup
715	* always has either children cgroups and/or using tasks. So we don't
716	* need a special hack to ensure that top_cgroup cannot be deleted.
717	*
718	* The task_lock() exception
719	*
720	* The need for this exception arises from the action of
721	* cgroup_attach_task(), which overwrites one tasks cgroup pointer with
722	* another. It does so using cgroup_mutex, however there are
723	* several performance critical places that need to reference
724	* task->cgroup without the expense of grabbing a system global
725	* mutex. Therefore except as noted below, when dereferencing or, as
726	* in cgroup_attach_task(), modifying a task'ss cgroup pointer we use
727	* task_lock(), which acts on a spinlock (task->alloc_lock) already in
728	* the task_struct routinely used for such matters.
729	*
730	* P.S. One more locking exception. RCU is used to guard the
731	* update of a tasks cgroup pointer by cgroup_attach_task()
732	*/
733
734	/**
735	* cgroup_lock - lock out any changes to cgroup structures
736	*
737	*/
738	void cgroup_lock(void)
739	{
740	mutex_lock(&cgroup_mutex);
741	}
742	EXPORT_SYMBOL_GPL(cgroup_lock);
743
744	/**
745	* cgroup_unlock - release lock on cgroup changes
746	*
747	* Undo the lock taken in a previous cgroup_lock() call.
748	*/
749	void cgroup_unlock(void)
750	{
751	mutex_unlock(&cgroup_mutex);
752	}
753	EXPORT_SYMBOL_GPL(cgroup_unlock);
754
755	/*
756	* A couple of forward declarations required, due to cyclic reference loop:
757	* cgroup_mkdir -> cgroup_create -> cgroup_populate_dir ->
758	* cgroup_add_file -> cgroup_create_file -> cgroup_dir_inode_operations
759	* -> cgroup_mkdir.
760	*/
761
762	static int cgroup_mkdir(struct inode dir, struct dentry dentry, int mode);
763	static int cgroup_rmdir(struct inode unused_dir, struct dentry dentry);
764	static int cgroup_populate_dir(struct cgroup *cgrp);
765	static const struct inode_operations cgroup_dir_inode_operations;
766	static const struct file_operations proc_cgroupstats_operations;
767
768	static struct backing_dev_info cgroup_backing_dev_info = {
769	.name = "cgroup",
770	.capabilities = BDI_CAP_NO_ACCT_AND_WRITEBACK,
771	};
772
773	static int alloc_css_id(struct cgroup_subsys *ss,
774	struct cgroup parent, struct cgroup child);
775
776	static struct inode cgroup_new_inode(mode_t mode, struct super_block sb)
777	{
778	struct inode *inode = new_inode(sb);
779
780	if (inode) {
781	inode->i_mode = mode;
782	inode->i_uid = current_fsuid();
783	inode->i_gid = current_fsgid();
784	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
785	inode->i_mapping->backing_dev_info = &cgroup_backing_dev_info;
786	}
787	return inode;
788	}
789
790	/*
791	* Call subsys's pre_destroy handler.
792	* This is called before css refcnt check.
793	*/
794	static int cgroup_call_pre_destroy(struct cgroup *cgrp)
795	{
796	struct cgroup_subsys *ss;
797	int ret = 0;
798
799	for_each_subsys(cgrp->root, ss)
800	if (ss->pre_destroy) {
801	ret = ss->pre_destroy(ss, cgrp);
802	if (ret)
803	break;
804	}
805
806	return ret;
807	}
808
809	static void free_cgroup_rcu(struct rcu_head *obj)
810	{
811	struct cgroup *cgrp = container_of(obj, struct cgroup, rcu_head);
812
813	kfree(cgrp);
814	}
815
816	static void cgroup_diput(struct dentry dentry, struct inode inode)
817	{
818	/* is dentry a directory ? if so, kfree() associated cgroup */
819	if (S_ISDIR(inode->i_mode)) {
820	struct cgroup *cgrp = dentry->d_fsdata;
821	struct cgroup_subsys *ss;
822	BUG_ON(!(cgroup_is_removed(cgrp)));
823	/* It's possible for external users to be holding css
824	* reference counts on a cgroup; css_put() needs to
825	* be able to access the cgroup after decrementing
826	* the reference count in order to know if it needs to
827	* queue the cgroup to be handled by the release
828	* agent */
829	synchronize_rcu();
830
831	mutex_lock(&cgroup_mutex);
832	/*
833	* Release the subsystem state objects.
834	*/
835	for_each_subsys(cgrp->root, ss)
836	ss->destroy(ss, cgrp);
837
838	cgrp->root->number_of_cgroups--;
839	mutex_unlock(&cgroup_mutex);
840
841	/*
842	* Drop the active superblock reference that we took when we
843	* created the cgroup
844	*/
845	deactivate_super(cgrp->root->sb);
846
847	/*
848	* if we're getting rid of the cgroup, refcount should ensure
849	* that there are no pidlists left.
850	*/
851	BUG_ON(!list_empty(&cgrp->pidlists));
852
853	call_rcu(&cgrp->rcu_head, free_cgroup_rcu);
854	}
855	iput(inode);
856	}
857
858	static void remove_dir(struct dentry *d)
859	{
860	struct dentry *parent = dget(d->d_parent);
861
862	d_delete(d);
863	simple_rmdir(parent->d_inode, d);
864	dput(parent);
865	}
866
867	static void cgroup_clear_directory(struct dentry *dentry)
868	{
869	struct list_head *node;
870
871	BUG_ON(!mutex_is_locked(&dentry->d_inode->i_mutex));
872	spin_lock(&dcache_lock);
873	node = dentry->d_subdirs.next;
874	while (node != &dentry->d_subdirs) {
875	struct dentry *d = list_entry(node, struct dentry, d_u.d_child);
876	list_del_init(node);
877	if (d->d_inode) {
878	/* This should never be called on a cgroup
879	* directory with child cgroups */
880	BUG_ON(d->d_inode->i_mode & S_IFDIR);
881	d = dget_locked(d);
882	spin_unlock(&dcache_lock);
883	d_delete(d);
884	simple_unlink(dentry->d_inode, d);
885	dput(d);
886	spin_lock(&dcache_lock);
887	}
888	node = dentry->d_subdirs.next;
889	}
890	spin_unlock(&dcache_lock);
891	}
892
893	/*
894	* NOTE : the dentry must have been dget()'ed
895	*/
896	static void cgroup_d_remove_dir(struct dentry *dentry)
897	{
898	cgroup_clear_directory(dentry);
899
900	spin_lock(&dcache_lock);
901	list_del_init(&dentry->d_u.d_child);
902	spin_unlock(&dcache_lock);
903	remove_dir(dentry);
904	}
905
906	/*
907	* A queue for waiters to do rmdir() cgroup. A tasks will sleep when
908	* cgroup->count == 0 && list_empty(&cgroup->children) && subsys has some
909	* reference to css->refcnt. In general, this refcnt is expected to goes down
910	* to zero, soon.
911	*
912	* CGRP_WAIT_ON_RMDIR flag is set under cgroup's inode->i_mutex;
913	*/
914	DECLARE_WAIT_QUEUE_HEAD(cgroup_rmdir_waitq);
915
916	static void cgroup_wakeup_rmdir_waiter(struct cgroup *cgrp)
917	{
918	if (unlikely(test_and_clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags)))
919	wake_up_all(&cgroup_rmdir_waitq);
920	}
921
922	void cgroup_exclude_rmdir(struct cgroup_subsys_state *css)
923	{
924	css_get(css);
925	}
926
927	void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css)
928	{
929	cgroup_wakeup_rmdir_waiter(css->cgroup);
930	css_put(css);
931	}
932
933	/*
934	* Call with cgroup_mutex held. Drops reference counts on modules, including
935	* any duplicate ones that parse_cgroupfs_options took. If this function
936	* returns an error, no reference counts are touched.
937	*/
938	static int rebind_subsystems(struct cgroupfs_root *root,
939	unsigned long final_bits)
940	{
941	unsigned long added_bits, removed_bits;
942	struct cgroup *cgrp = &root->top_cgroup;
943	int i;
944
945	BUG_ON(!mutex_is_locked(&cgroup_mutex));
946
947	removed_bits = root->actual_subsys_bits & ~final_bits;
948	added_bits = final_bits & ~root->actual_subsys_bits;
949	/* Check that any added subsystems are currently free */
950	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
951	unsigned long bit = 1UL << i;
952	struct cgroup_subsys *ss = subsys[i];
953	if (!(bit & added_bits))
954	continue;
955	/*
956	* Nobody should tell us to do a subsys that doesn't exist:
957	* parse_cgroupfs_options should catch that case and refcounts
958	* ensure that subsystems won't disappear once selected.
959	*/
960	BUG_ON(ss == NULL);
961	if (ss->root != &rootnode) {
962	/* Subsystem isn't free */
963	return -EBUSY;
964	}
965	}
966
967	/* Currently we don't handle adding/removing subsystems when
968	* any child cgroups exist. This is theoretically supportable
969	* but involves complex error handling, so it's being left until
970	* later */
971	if (root->number_of_cgroups > 1)
972	return -EBUSY;
973
974	/* Process each subsystem */
975	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
976	struct cgroup_subsys *ss = subsys[i];
977	unsigned long bit = 1UL << i;
978	if (bit & added_bits) {
979	/* We're binding this subsystem to this hierarchy */
980	BUG_ON(ss == NULL);
981	BUG_ON(cgrp->subsys[i]);
982	BUG_ON(!dummytop->subsys[i]);
983	BUG_ON(dummytop->subsys[i]->cgroup != dummytop);
984	mutex_lock(&ss->hierarchy_mutex);
985	cgrp->subsys[i] = dummytop->subsys[i];
986	cgrp->subsys[i]->cgroup = cgrp;
987	list_move(&ss->sibling, &root->subsys_list);
988	ss->root = root;
989	if (ss->bind)
990	ss->bind(ss, cgrp);
991	mutex_unlock(&ss->hierarchy_mutex);
992	/* refcount was already taken, and we're keeping it */
993	} else if (bit & removed_bits) {
994	/* We're removing this subsystem */
995	BUG_ON(ss == NULL);
996	BUG_ON(cgrp->subsys[i] != dummytop->subsys[i]);
997	BUG_ON(cgrp->subsys[i]->cgroup != cgrp);
998	mutex_lock(&ss->hierarchy_mutex);
999	if (ss->bind)
1000	ss->bind(ss, dummytop);
1001	dummytop->subsys[i]->cgroup = dummytop;
1002	cgrp->subsys[i] = NULL;
1003	subsys[i]->root = &rootnode;
1004	list_move(&ss->sibling, &rootnode.subsys_list);
1005	mutex_unlock(&ss->hierarchy_mutex);
1006	/* subsystem is now free - drop reference on module */
1007	module_put(ss->module);
1008	} else if (bit & final_bits) {
1009	/* Subsystem state should already exist */
1010	BUG_ON(ss == NULL);
1011	BUG_ON(!cgrp->subsys[i]);
1012	/*
1013	* a refcount was taken, but we already had one, so
1014	* drop the extra reference.
1015	*/
1016	module_put(ss->module);
1017	#ifdef CONFIG_MODULE_UNLOAD
1018	BUG_ON(ss->module && !module_refcount(ss->module));
1019	#endif
1020	} else {
1021	/* Subsystem state shouldn't exist */
1022	BUG_ON(cgrp->subsys[i]);
1023	}
1024	}
1025	root->subsys_bits = root->actual_subsys_bits = final_bits;
1026	synchronize_rcu();
1027
1028	return 0;
1029	}
1030
1031	static int cgroup_show_options(struct seq_file seq, struct vfsmount vfs)
1032	{
1033	struct cgroupfs_root *root = vfs->mnt_sb->s_fs_info;
1034	struct cgroup_subsys *ss;
1035
1036	mutex_lock(&cgroup_mutex);
1037	for_each_subsys(root, ss)
1038	seq_printf(seq, ",%s", ss->name);
1039	if (test_bit(ROOT_NOPREFIX, &root->flags))
1040	seq_puts(seq, ",noprefix");
1041	if (strlen(root->release_agent_path))
1042	seq_printf(seq, ",release_agent=%s", root->release_agent_path);
1043	if (strlen(root->name))
1044	seq_printf(seq, ",name=%s", root->name);
1045	mutex_unlock(&cgroup_mutex);
1046	return 0;
1047	}
1048
1049	struct cgroup_sb_opts {
1050	unsigned long subsys_bits;
1051	unsigned long flags;
1052	char *release_agent;
1053	char *name;
1054	/* User explicitly requested empty subsystem */
1055	bool none;
1056
1057	struct cgroupfs_root *new_root;
1058
1059	};
1060
1061	/*
1062	* Convert a hierarchy specifier into a bitmask of subsystems and flags. Call
1063	* with cgroup_mutex held to protect the subsys[] array. This function takes
1064	* refcounts on subsystems to be used, unless it returns error, in which case
1065	* no refcounts are taken.
1066	*/
1067	static int parse_cgroupfs_options(char data, struct cgroup_sb_opts opts)
1068	{
1069	char token, o = data ?: "all";
1070	unsigned long mask = (unsigned long)-1;
1071	int i;
1072	bool module_pin_failed = false;
1073
1074	BUG_ON(!mutex_is_locked(&cgroup_mutex));
1075
1076	#ifdef CONFIG_CPUSETS
1077	mask = ~(1UL << cpuset_subsys_id);
1078	#endif
1079
1080	memset(opts, 0, sizeof(*opts));
1081
1082	while ((token = strsep(&o, ",")) != NULL) {
1083	if (!*token)
1084	return -EINVAL;
1085	if (!strcmp(token, "all")) {
1086	/* Add all non-disabled subsystems */
1087	opts->subsys_bits = 0;
1088	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
1089	struct cgroup_subsys *ss = subsys[i];
1090	if (ss == NULL)
1091	continue;
1092	if (!ss->disabled)
1093	opts->subsys_bits \|= 1ul << i;
1094	}
1095	} else if (!strcmp(token, "none")) {
1096	/* Explicitly have no subsystems */
1097	opts->none = true;
1098	} else if (!strcmp(token, "noprefix")) {
1099	set_bit(ROOT_NOPREFIX, &opts->flags);
1100	} else if (!strncmp(token, "release_agent=", 14)) {
1101	/* Specifying two release agents is forbidden */
1102	if (opts->release_agent)
1103	return -EINVAL;
1104	opts->release_agent =
1105	kstrndup(token + 14, PATH_MAX, GFP_KERNEL);
1106	if (!opts->release_agent)
1107	return -ENOMEM;
1108	} else if (!strncmp(token, "name=", 5)) {
1109	const char *name = token + 5;
1110	/* Can't specify an empty name */
1111	if (!strlen(name))
1112	return -EINVAL;
1113	/* Must match [\w.-]+ */
1114	for (i = 0; i < strlen(name); i++) {
1115	char c = name[i];
1116	if (isalnum(c))
1117	continue;
1118	if ((c == '.') \|\| (c == '-') \|\| (c == '_'))
1119	continue;
1120	return -EINVAL;
1121	}
1122	/* Specifying two names is forbidden */
1123	if (opts->name)
1124	return -EINVAL;
1125	opts->name = kstrndup(name,
1126	MAX_CGROUP_ROOT_NAMELEN,
1127	GFP_KERNEL);
1128	if (!opts->name)
1129	return -ENOMEM;
1130	} else {
1131	struct cgroup_subsys *ss;
1132	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
1133	ss = subsys[i];
1134	if (ss == NULL)
1135	continue;
1136	if (!strcmp(token, ss->name)) {
1137	if (!ss->disabled)
1138	set_bit(i, &opts->subsys_bits);
1139	break;
1140	}
1141	}
1142	if (i == CGROUP_SUBSYS_COUNT)
1143	return -ENOENT;
1144	}
1145	}
1146
1147	/* Consistency checks */
1148
1149	/*
1150	* Option noprefix was introduced just for backward compatibility
1151	* with the old cpuset, so we allow noprefix only if mounting just
1152	* the cpuset subsystem.
1153	*/
1154	if (test_bit(ROOT_NOPREFIX, &opts->flags) &&
1155	(opts->subsys_bits & mask))
1156	return -EINVAL;
1157
1158
1159	/* Can't specify "none" and some subsystems */
1160	if (opts->subsys_bits && opts->none)
1161	return -EINVAL;
1162
1163	/*
1164	* We either have to specify by name or by subsystems. (So all
1165	* empty hierarchies must have a name).
1166	*/
1167	if (!opts->subsys_bits && !opts->name)
1168	return -EINVAL;
1169
1170	/*
1171	* Grab references on all the modules we'll need, so the subsystems
1172	* don't dance around before rebind_subsystems attaches them. This may
1173	* take duplicate reference counts on a subsystem that's already used,
1174	* but rebind_subsystems handles this case.
1175	*/
1176	for (i = CGROUP_BUILTIN_SUBSYS_COUNT; i < CGROUP_SUBSYS_COUNT; i++) {
1177	unsigned long bit = 1UL << i;
1178
1179	if (!(bit & opts->subsys_bits))
1180	continue;
1181	if (!try_module_get(subsys[i]->module)) {
1182	module_pin_failed = true;
1183	break;
1184	}
1185	}
1186	if (module_pin_failed) {
1187	/*
1188	* oops, one of the modules was going away. this means that we
1189	* raced with a module_delete call, and to the user this is
1190	* essentially a "subsystem doesn't exist" case.
1191	*/
1192	for (i--; i >= CGROUP_BUILTIN_SUBSYS_COUNT; i--) {
1193	/* drop refcounts only on the ones we took */
1194	unsigned long bit = 1UL << i;
1195
1196	if (!(bit & opts->subsys_bits))
1197	continue;
1198	module_put(subsys[i]->module);
1199	}
1200	return -ENOENT;
1201	}
1202
1203	return 0;
1204	}
1205
1206	static void drop_parsed_module_refcounts(unsigned long subsys_bits)
1207	{
1208	int i;
1209	for (i = CGROUP_BUILTIN_SUBSYS_COUNT; i < CGROUP_SUBSYS_COUNT; i++) {
1210	unsigned long bit = 1UL << i;
1211
1212	if (!(bit & subsys_bits))
1213	continue;
1214	module_put(subsys[i]->module);
1215	}
1216	}
1217
1218	static int cgroup_remount(struct super_block sb, int flags, char *data)
1219	{
1220	int ret = 0;
1221	struct cgroupfs_root *root = sb->s_fs_info;
1222	struct cgroup *cgrp = &root->top_cgroup;
1223	struct cgroup_sb_opts opts;
1224
1225	lock_kernel();
1226	mutex_lock(&cgrp->dentry->d_inode->i_mutex);
1227	mutex_lock(&cgroup_mutex);
1228
1229	/* See what subsystems are wanted */
1230	ret = parse_cgroupfs_options(data, &opts);
1231	if (ret)
1232	goto out_unlock;
1233
1234	/* Don't allow flags or name to change at remount */
1235	if (opts.flags != root->flags \|\|
1236	(opts.name && strcmp(opts.name, root->name))) {
1237	ret = -EINVAL;
1238	drop_parsed_module_refcounts(opts.subsys_bits);
1239	goto out_unlock;
1240	}
1241
1242	ret = rebind_subsystems(root, opts.subsys_bits);
1243	if (ret) {
1244	drop_parsed_module_refcounts(opts.subsys_bits);
1245	goto out_unlock;
1246	}
1247
1248	/* (re)populate subsystem files */
1249	cgroup_populate_dir(cgrp);
1250
1251	if (opts.release_agent)
1252	strcpy(root->release_agent_path, opts.release_agent);
1253	out_unlock:
1254	kfree(opts.release_agent);
1255	kfree(opts.name);
1256	mutex_unlock(&cgroup_mutex);
1257	mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
1258	unlock_kernel();
1259	return ret;
1260	}
1261
1262	static const struct super_operations cgroup_ops = {
1263	.statfs = simple_statfs,
1264	.drop_inode = generic_delete_inode,
1265	.show_options = cgroup_show_options,
1266	.remount_fs = cgroup_remount,
1267	};
1268
1269	static void init_cgroup_housekeeping(struct cgroup *cgrp)
1270	{
1271	INIT_LIST_HEAD(&cgrp->sibling);
1272	INIT_LIST_HEAD(&cgrp->children);
1273	INIT_LIST_HEAD(&cgrp->css_sets);
1274	INIT_LIST_HEAD(&cgrp->release_list);
1275	INIT_LIST_HEAD(&cgrp->pidlists);
1276	mutex_init(&cgrp->pidlist_mutex);
1277	INIT_LIST_HEAD(&cgrp->event_list);
1278	spin_lock_init(&cgrp->event_list_lock);
1279	}
1280
1281	static void init_cgroup_root(struct cgroupfs_root *root)
1282	{
1283	struct cgroup *cgrp = &root->top_cgroup;
1284	INIT_LIST_HEAD(&root->subsys_list);
1285	INIT_LIST_HEAD(&root->root_list);
1286	root->number_of_cgroups = 1;
1287	cgrp->root = root;
1288	cgrp->top_cgroup = cgrp;
1289	init_cgroup_housekeeping(cgrp);
1290	}
1291
1292	static bool init_root_id(struct cgroupfs_root *root)
1293	{
1294	int ret = 0;
1295
1296	do {
1297	if (!ida_pre_get(&hierarchy_ida, GFP_KERNEL))
1298	return false;
1299	spin_lock(&hierarchy_id_lock);
1300	/* Try to allocate the next unused ID */
1301	ret = ida_get_new_above(&hierarchy_ida, next_hierarchy_id,
1302	&root->hierarchy_id);
1303	if (ret == -ENOSPC)
1304	/* Try again starting from 0 */
1305	ret = ida_get_new(&hierarchy_ida, &root->hierarchy_id);
1306	if (!ret) {
1307	next_hierarchy_id = root->hierarchy_id + 1;
1308	} else if (ret != -EAGAIN) {
1309	/* Can only get here if the 31-bit IDR is full ... */
1310	BUG_ON(ret);
1311	}
1312	spin_unlock(&hierarchy_id_lock);
1313	} while (ret);
1314	return true;
1315	}
1316
1317	static int cgroup_test_super(struct super_block sb, void data)
1318	{
1319	struct cgroup_sb_opts *opts = data;
1320	struct cgroupfs_root *root = sb->s_fs_info;
1321
1322	/* If we asked for a name then it must match */
1323	if (opts->name && strcmp(opts->name, root->name))
1324	return 0;
1325
1326	/*
1327	* If we asked for subsystems (or explicitly for no
1328	* subsystems) then they must match
1329	*/
1330	if ((opts->subsys_bits \|\| opts->none)
1331	&& (opts->subsys_bits != root->subsys_bits))
1332	return 0;
1333
1334	return 1;
1335	}
1336
1337	static struct cgroupfs_root cgroup_root_from_opts(struct cgroup_sb_opts opts)
1338	{
1339	struct cgroupfs_root *root;
1340
1341	if (!opts->subsys_bits && !opts->none)
1342	return NULL;
1343
1344	root = kzalloc(sizeof(*root), GFP_KERNEL);
1345	if (!root)
1346	return ERR_PTR(-ENOMEM);
1347
1348	if (!init_root_id(root)) {
1349	kfree(root);
1350	return ERR_PTR(-ENOMEM);
1351	}
1352	init_cgroup_root(root);
1353
1354	root->subsys_bits = opts->subsys_bits;
1355	root->flags = opts->flags;
1356	if (opts->release_agent)
1357	strcpy(root->release_agent_path, opts->release_agent);
1358	if (opts->name)
1359	strcpy(root->name, opts->name);
1360	return root;
1361	}
1362
1363	static void cgroup_drop_root(struct cgroupfs_root *root)
1364	{
1365	if (!root)
1366	return;
1367
1368	BUG_ON(!root->hierarchy_id);
1369	spin_lock(&hierarchy_id_lock);
1370	ida_remove(&hierarchy_ida, root->hierarchy_id);
1371	spin_unlock(&hierarchy_id_lock);
1372	kfree(root);
1373	}
1374
1375	static int cgroup_set_super(struct super_block sb, void data)
1376	{
1377	int ret;
1378	struct cgroup_sb_opts *opts = data;
1379
1380	/* If we don't have a new root, we can't set up a new sb */
1381	if (!opts->new_root)
1382	return -EINVAL;
1383
1384	BUG_ON(!opts->subsys_bits && !opts->none);
1385
1386	ret = set_anon_super(sb, NULL);
1387	if (ret)
1388	return ret;
1389
1390	sb->s_fs_info = opts->new_root;
1391	opts->new_root->sb = sb;
1392
1393	sb->s_blocksize = PAGE_CACHE_SIZE;
1394	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1395	sb->s_magic = CGROUP_SUPER_MAGIC;
1396	sb->s_op = &cgroup_ops;
1397
1398	return 0;
1399	}
1400
1401	static int cgroup_get_rootdir(struct super_block *sb)
1402	{
1403	struct inode *inode =
1404	cgroup_new_inode(S_IFDIR \| S_IRUGO \| S_IXUGO \| S_IWUSR, sb);
1405	struct dentry *dentry;
1406
1407	if (!inode)
1408	return -ENOMEM;
1409
1410	inode->i_fop = &simple_dir_operations;
1411	inode->i_op = &cgroup_dir_inode_operations;
1412	/* directories start off with i_nlink == 2 (for "." entry) */
1413	inc_nlink(inode);
1414	dentry = d_alloc_root(inode);
1415	if (!dentry) {
1416	iput(inode);
1417	return -ENOMEM;
1418	}
1419	sb->s_root = dentry;
1420	return 0;
1421	}
1422
1423	static int cgroup_get_sb(struct file_system_type *fs_type,
1424	int flags, const char *unused_dev_name,
1425	void data, struct vfsmount mnt)
1426	{
1427	struct cgroup_sb_opts opts;
1428	struct cgroupfs_root *root;
1429	int ret = 0;
1430	struct super_block *sb;
1431	struct cgroupfs_root *new_root;
1432
1433	/* First find the desired set of subsystems */
1434	mutex_lock(&cgroup_mutex);
1435	ret = parse_cgroupfs_options(data, &opts);
1436	mutex_unlock(&cgroup_mutex);
1437	if (ret)
1438	goto out_err;
1439
1440	/*
1441	* Allocate a new cgroup root. We may not need it if we're
1442	* reusing an existing hierarchy.
1443	*/
1444	new_root = cgroup_root_from_opts(&opts);
1445	if (IS_ERR(new_root)) {
1446	ret = PTR_ERR(new_root);
1447	goto drop_modules;
1448	}
1449	opts.new_root = new_root;
1450
1451	/* Locate an existing or new sb for this hierarchy */
1452	sb = sget(fs_type, cgroup_test_super, cgroup_set_super, &opts);
1453	if (IS_ERR(sb)) {
1454	ret = PTR_ERR(sb);
1455	cgroup_drop_root(opts.new_root);
1456	goto drop_modules;
1457	}
1458
1459	root = sb->s_fs_info;
1460	BUG_ON(!root);
1461	if (root == opts.new_root) {
1462	/* We used the new root structure, so this is a new hierarchy */
1463	struct list_head tmp_cg_links;
1464	struct cgroup *root_cgrp = &root->top_cgroup;
1465	struct inode *inode;
1466	struct cgroupfs_root *existing_root;
1467	int i;
1468
1469	BUG_ON(sb->s_root != NULL);
1470
1471	ret = cgroup_get_rootdir(sb);
1472	if (ret)
1473	goto drop_new_super;
1474	inode = sb->s_root->d_inode;
1475
1476	mutex_lock(&inode->i_mutex);
1477	mutex_lock(&cgroup_mutex);
1478
1479	if (strlen(root->name)) {
1480	/* Check for name clashes with existing mounts */
1481	for_each_active_root(existing_root) {
1482	if (!strcmp(existing_root->name, root->name)) {
1483	ret = -EBUSY;
1484	mutex_unlock(&cgroup_mutex);
1485	mutex_unlock(&inode->i_mutex);
1486	goto drop_new_super;
1487	}
1488	}
1489	}
1490
1491	/*
1492	* We're accessing css_set_count without locking
1493	* css_set_lock here, but that's OK - it can only be
1494	* increased by someone holding cgroup_lock, and
1495	* that's us. The worst that can happen is that we
1496	* have some link structures left over
1497	*/
1498	ret = allocate_cg_links(css_set_count, &tmp_cg_links);
1499	if (ret) {
1500	mutex_unlock(&cgroup_mutex);
1501	mutex_unlock(&inode->i_mutex);
1502	goto drop_new_super;
1503	}
1504
1505	ret = rebind_subsystems(root, root->subsys_bits);
1506	if (ret == -EBUSY) {
1507	mutex_unlock(&cgroup_mutex);
1508	mutex_unlock(&inode->i_mutex);
1509	free_cg_links(&tmp_cg_links);
1510	goto drop_new_super;
1511	}
1512	/*
1513	* There must be no failure case after here, since rebinding
1514	* takes care of subsystems' refcounts, which are explicitly
1515	* dropped in the failure exit path.
1516	*/
1517
1518	/* EBUSY should be the only error here */
1519	BUG_ON(ret);
1520
1521	list_add(&root->root_list, &roots);
1522	root_count++;
1523
1524	sb->s_root->d_fsdata = root_cgrp;
1525	root->top_cgroup.dentry = sb->s_root;
1526
1527	/* Link the top cgroup in this hierarchy into all
1528	* the css_set objects */
1529	write_lock(&css_set_lock);
1530	for (i = 0; i < CSS_SET_TABLE_SIZE; i++) {
1531	struct hlist_head *hhead = &css_set_table[i];
1532	struct hlist_node *node;
1533	struct css_set *cg;
1534
1535	hlist_for_each_entry(cg, node, hhead, hlist)
1536	link_css_set(&tmp_cg_links, cg, root_cgrp);
1537	}
1538	write_unlock(&css_set_lock);
1539
1540	free_cg_links(&tmp_cg_links);
1541
1542	BUG_ON(!list_empty(&root_cgrp->sibling));
1543	BUG_ON(!list_empty(&root_cgrp->children));
1544	BUG_ON(root->number_of_cgroups != 1);
1545
1546	cgroup_populate_dir(root_cgrp);
1547	mutex_unlock(&cgroup_mutex);
1548	mutex_unlock(&inode->i_mutex);
1549	} else {
1550	/*
1551	* We re-used an existing hierarchy - the new root (if
1552	* any) is not needed
1553	*/
1554	cgroup_drop_root(opts.new_root);
1555	/* no subsys rebinding, so refcounts don't change */
1556	drop_parsed_module_refcounts(opts.subsys_bits);
1557	}
1558
1559	simple_set_mnt(mnt, sb);
1560	kfree(opts.release_agent);
1561	kfree(opts.name);
1562	return 0;
1563
1564	drop_new_super:
1565	deactivate_locked_super(sb);
1566	drop_modules:
1567	drop_parsed_module_refcounts(opts.subsys_bits);
1568	out_err:
1569	kfree(opts.release_agent);
1570	kfree(opts.name);
1571
1572	return ret;
1573	}
1574
1575	static void cgroup_kill_sb(struct super_block *sb) {
1576	struct cgroupfs_root *root = sb->s_fs_info;
1577	struct cgroup *cgrp = &root->top_cgroup;
1578	int ret;
1579	struct cg_cgroup_link *link;
1580	struct cg_cgroup_link *saved_link;
1581
1582	BUG_ON(!root);
1583
1584	BUG_ON(root->number_of_cgroups != 1);
1585	BUG_ON(!list_empty(&cgrp->children));
1586	BUG_ON(!list_empty(&cgrp->sibling));
1587
1588	mutex_lock(&cgroup_mutex);
1589
1590	/* Rebind all subsystems back to the default hierarchy */
1591	ret = rebind_subsystems(root, 0);
1592	/* Shouldn't be able to fail ... */
1593	BUG_ON(ret);
1594
1595	/*
1596	* Release all the links from css_sets to this hierarchy's
1597	* root cgroup
1598	*/
1599	write_lock(&css_set_lock);
1600
1601	list_for_each_entry_safe(link, saved_link, &cgrp->css_sets,
1602	cgrp_link_list) {
1603	list_del(&link->cg_link_list);
1604	list_del(&link->cgrp_link_list);
1605	kfree(link);
1606	}
1607	write_unlock(&css_set_lock);
1608
1609	if (!list_empty(&root->root_list)) {
1610	list_del(&root->root_list);
1611	root_count--;
1612	}
1613
1614	mutex_unlock(&cgroup_mutex);
1615
1616	kill_litter_super(sb);
1617	cgroup_drop_root(root);
1618	}
1619
1620	static struct file_system_type cgroup_fs_type = {
1621	.name = "cgroup",
1622	.get_sb = cgroup_get_sb,
1623	.kill_sb = cgroup_kill_sb,
1624	};
1625
1626	static inline struct cgroup __d_cgrp(struct dentry dentry)
1627	{
1628	return dentry->d_fsdata;
1629	}
1630
1631	static inline struct cftype __d_cft(struct dentry dentry)
1632	{
1633	return dentry->d_fsdata;
1634	}
1635
1636	/**
1637	* cgroup_path - generate the path of a cgroup
1638	* @cgrp: the cgroup in question
1639	* @buf: the buffer to write the path into
1640	* @buflen: the length of the buffer
1641	*
1642	* Called with cgroup_mutex held or else with an RCU-protected cgroup
1643	* reference. Writes path of cgroup into buf. Returns 0 on success,
1644	* -errno on error.
1645	*/
1646	int cgroup_path(const struct cgroup cgrp, char buf, int buflen)
1647	{
1648	char *start;
1649	struct dentry *dentry = rcu_dereference(cgrp->dentry);
1650
1651	if (!dentry \|\| cgrp == dummytop) {
1652	/*
1653	* Inactive subsystems have no dentry for their root
1654	* cgroup
1655	*/
1656	strcpy(buf, "/");
1657	return 0;
1658	}
1659
1660	start = buf + buflen;
1661
1662	*--start = '\0';
1663	for (;;) {
1664	int len = dentry->d_name.len;
1665	if ((start -= len) < buf)
1666	return -ENAMETOOLONG;
1667	memcpy(start, cgrp->dentry->d_name.name, len);
1668	cgrp = cgrp->parent;
1669	if (!cgrp)
1670	break;
1671	dentry = rcu_dereference(cgrp->dentry);
1672	if (!cgrp->parent)
1673	continue;
1674	if (--start < buf)
1675	return -ENAMETOOLONG;
1676	*start = '/';
1677	}
1678	memmove(buf, start, buf + buflen - start);
1679	return 0;
1680	}
1681	EXPORT_SYMBOL_GPL(cgroup_path);
1682
1683	/**
1684	* cgroup_attach_task - attach task 'tsk' to cgroup 'cgrp'
1685	* @cgrp: the cgroup the task is attaching to
1686	* @tsk: the task to be attached
1687	*
1688	* Call holding cgroup_mutex. May take task_lock of
1689	* the task 'tsk' during call.
1690	*/
1691	int cgroup_attach_task(struct cgroup cgrp, struct task_struct tsk)
1692	{
1693	int retval = 0;
1694	struct cgroup_subsys ss, failed_ss = NULL;
1695	struct cgroup *oldcgrp;
1696	struct css_set *cg;
1697	struct css_set *newcg;
1698	struct cgroupfs_root *root = cgrp->root;
1699
1700	/* Nothing to do if the task is already in that cgroup */
1701	oldcgrp = task_cgroup_from_root(tsk, root);
1702	if (cgrp == oldcgrp)
1703	return 0;
1704
1705	for_each_subsys(root, ss) {
1706	if (ss->can_attach) {
1707	retval = ss->can_attach(ss, cgrp, tsk, false);
1708	if (retval) {
1709	/*
1710	* Remember on which subsystem the can_attach()
1711	* failed, so that we only call cancel_attach()
1712	* against the subsystems whose can_attach()
1713	* succeeded. (See below)
1714	*/
1715	failed_ss = ss;
1716	goto out;
1717	}
1718	}
1719	}
1720
1721	task_lock(tsk);
1722	cg = tsk->cgroups;
1723	get_css_set(cg);
1724	task_unlock(tsk);
1725	/*
1726	* Locate or allocate a new css_set for this task,
1727	* based on its final set of cgroups
1728	*/
1729	newcg = find_css_set(cg, cgrp);
1730	put_css_set(cg);
1731	if (!newcg) {
1732	retval = -ENOMEM;
1733	goto out;
1734	}
1735
1736	task_lock(tsk);
1737	if (tsk->flags & PF_EXITING) {
1738	task_unlock(tsk);
1739	put_css_set(newcg);
1740	retval = -ESRCH;
1741	goto out;
1742	}
1743	rcu_assign_pointer(tsk->cgroups, newcg);
1744	task_unlock(tsk);
1745
1746	/* Update the css_set linked lists if we're using them */
1747	write_lock(&css_set_lock);
1748	if (!list_empty(&tsk->cg_list)) {
1749	list_del(&tsk->cg_list);
1750	list_add(&tsk->cg_list, &newcg->tasks);
1751	}
1752	write_unlock(&css_set_lock);
1753
1754	for_each_subsys(root, ss) {
1755	if (ss->attach)
1756	ss->attach(ss, cgrp, oldcgrp, tsk, false);
1757	}
1758	set_bit(CGRP_RELEASABLE, &oldcgrp->flags);
1759	synchronize_rcu();
1760	put_css_set(cg);
1761
1762	/*
1763	* wake up rmdir() waiter. the rmdir should fail since the cgroup
1764	* is no longer empty.
1765	*/
1766	cgroup_wakeup_rmdir_waiter(cgrp);
1767	out:
1768	if (retval) {
1769	for_each_subsys(root, ss) {
1770	if (ss == failed_ss)
1771	/*
1772	* This subsystem was the one that failed the
1773	* can_attach() check earlier, so we don't need
1774	* to call cancel_attach() against it or any
1775	* remaining subsystems.
1776	*/
1777	break;
1778	if (ss->cancel_attach)
1779	ss->cancel_attach(ss, cgrp, tsk, false);
1780	}
1781	}
1782	return retval;
1783	}
1784
1785	/*
1786	* Attach task with pid 'pid' to cgroup 'cgrp'. Call with cgroup_mutex
1787	* held. May take task_lock of task
1788	*/
1789	static int attach_task_by_pid(struct cgroup *cgrp, u64 pid)
1790	{
1791	struct task_struct *tsk;
1792	const struct cred cred = current_cred(), tcred;
1793	int ret;
1794
1795	if (pid) {
1796	rcu_read_lock();
1797	tsk = find_task_by_vpid(pid);
1798	if (!tsk \|\| tsk->flags & PF_EXITING) {
1799	rcu_read_unlock();
1800	return -ESRCH;
1801	}
1802
1803	tcred = __task_cred(tsk);
1804	if (cred->euid &&
1805	cred->euid != tcred->uid &&
1806	cred->euid != tcred->suid) {
1807	rcu_read_unlock();
1808	return -EACCES;
1809	}
1810	get_task_struct(tsk);
1811	rcu_read_unlock();
1812	} else {
1813	tsk = current;
1814	get_task_struct(tsk);
1815	}
1816
1817	ret = cgroup_attach_task(cgrp, tsk);
1818	put_task_struct(tsk);
1819	return ret;
1820	}
1821
1822	static int cgroup_tasks_write(struct cgroup cgrp, struct cftype cft, u64 pid)
1823	{
1824	int ret;
1825	if (!cgroup_lock_live_group(cgrp))
1826	return -ENODEV;
1827	ret = attach_task_by_pid(cgrp, pid);
1828	cgroup_unlock();
1829	return ret;
1830	}
1831
1832	/**
1833	* cgroup_lock_live_group - take cgroup_mutex and check that cgrp is alive.
1834	* @cgrp: the cgroup to be checked for liveness
1835	*
1836	* On success, returns true; the lock should be later released with
1837	* cgroup_unlock(). On failure returns false with no lock held.
1838	*/
1839	bool cgroup_lock_live_group(struct cgroup *cgrp)
1840	{
1841	mutex_lock(&cgroup_mutex);
1842	if (cgroup_is_removed(cgrp)) {
1843	mutex_unlock(&cgroup_mutex);
1844	return false;
1845	}
1846	return true;
1847	}
1848	EXPORT_SYMBOL_GPL(cgroup_lock_live_group);
1849
1850	static int cgroup_release_agent_write(struct cgroup cgrp, struct cftype cft,
1851	const char *buffer)
1852	{
1853	BUILD_BUG_ON(sizeof(cgrp->root->release_agent_path) < PATH_MAX);
1854	if (!cgroup_lock_live_group(cgrp))
1855	return -ENODEV;
1856	strcpy(cgrp->root->release_agent_path, buffer);
1857	cgroup_unlock();
1858	return 0;
1859	}
1860
1861	static int cgroup_release_agent_show(struct cgroup cgrp, struct cftype cft,
1862	struct seq_file *seq)
1863	{
1864	if (!cgroup_lock_live_group(cgrp))
1865	return -ENODEV;
1866	seq_puts(seq, cgrp->root->release_agent_path);
1867	seq_putc(seq, '\n');
1868	cgroup_unlock();
1869	return 0;
1870	}
1871
1872	/* A buffer size big enough for numbers or short strings */
1873	#define CGROUP_LOCAL_BUFFER_SIZE 64
1874
1875	static ssize_t cgroup_write_X64(struct cgroup cgrp, struct cftype cft,
1876	struct file *file,
1877	const char __user *userbuf,
1878	size_t nbytes, loff_t *unused_ppos)
1879	{
1880	char buffer[CGROUP_LOCAL_BUFFER_SIZE];
1881	int retval = 0;
1882	char *end;
1883
1884	if (!nbytes)
1885	return -EINVAL;
1886	if (nbytes >= sizeof(buffer))
1887	return -E2BIG;
1888	if (copy_from_user(buffer, userbuf, nbytes))
1889	return -EFAULT;
1890
1891	buffer[nbytes] = 0; /* nul-terminate */
1892	if (cft->write_u64) {
1893	u64 val = simple_strtoull(strstrip(buffer), &end, 0);
1894	if (*end)
1895	return -EINVAL;
1896	retval = cft->write_u64(cgrp, cft, val);
1897	} else {
1898	s64 val = simple_strtoll(strstrip(buffer), &end, 0);
1899	if (*end)
1900	return -EINVAL;
1901	retval = cft->write_s64(cgrp, cft, val);
1902	}
1903	if (!retval)
1904	retval = nbytes;
1905	return retval;
1906	}
1907
1908	static ssize_t cgroup_write_string(struct cgroup cgrp, struct cftype cft,
1909	struct file *file,
1910	const char __user *userbuf,
1911	size_t nbytes, loff_t *unused_ppos)
1912	{
1913	char local_buffer[CGROUP_LOCAL_BUFFER_SIZE];
1914	int retval = 0;
1915	size_t max_bytes = cft->max_write_len;
1916	char *buffer = local_buffer;
1917
1918	if (!max_bytes)
1919	max_bytes = sizeof(local_buffer) - 1;
1920	if (nbytes >= max_bytes)
1921	return -E2BIG;
1922	/* Allocate a dynamic buffer if we need one */
1923	if (nbytes >= sizeof(local_buffer)) {
1924	buffer = kmalloc(nbytes + 1, GFP_KERNEL);
1925	if (buffer == NULL)
1926	return -ENOMEM;
1927	}
1928	if (nbytes && copy_from_user(buffer, userbuf, nbytes)) {
1929	retval = -EFAULT;
1930	goto out;
1931	}
1932
1933	buffer[nbytes] = 0; /* nul-terminate */
1934	retval = cft->write_string(cgrp, cft, strstrip(buffer));
1935	if (!retval)
1936	retval = nbytes;
1937	out:
1938	if (buffer != local_buffer)
1939	kfree(buffer);
1940	return retval;
1941	}
1942
1943	static ssize_t cgroup_file_write(struct file file, const char __user buf,
1944	size_t nbytes, loff_t *ppos)
1945	{
1946	struct cftype *cft = __d_cft(file->f_dentry);
1947	struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
1948
1949	if (cgroup_is_removed(cgrp))
1950	return -ENODEV;
1951	if (cft->write)
1952	return cft->write(cgrp, cft, file, buf, nbytes, ppos);
1953	if (cft->write_u64 \|\| cft->write_s64)
1954	return cgroup_write_X64(cgrp, cft, file, buf, nbytes, ppos);
1955	if (cft->write_string)
1956	return cgroup_write_string(cgrp, cft, file, buf, nbytes, ppos);
1957	if (cft->trigger) {
1958	int ret = cft->trigger(cgrp, (unsigned int)cft->private);
1959	return ret ? ret : nbytes;
1960	}
1961	return -EINVAL;
1962	}
1963
1964	static ssize_t cgroup_read_u64(struct cgroup cgrp, struct cftype cft,
1965	struct file *file,
1966	char __user *buf, size_t nbytes,
1967	loff_t *ppos)
1968	{
1969	char tmp[CGROUP_LOCAL_BUFFER_SIZE];
1970	u64 val = cft->read_u64(cgrp, cft);
1971	int len = sprintf(tmp, "%llu\n", (unsigned long long) val);
1972
1973	return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
1974	}
1975
1976	static ssize_t cgroup_read_s64(struct cgroup cgrp, struct cftype cft,
1977	struct file *file,
1978	char __user *buf, size_t nbytes,
1979	loff_t *ppos)
1980	{
1981	char tmp[CGROUP_LOCAL_BUFFER_SIZE];
1982	s64 val = cft->read_s64(cgrp, cft);
1983	int len = sprintf(tmp, "%lld\n", (long long) val);
1984
1985	return simple_read_from_buffer(buf, nbytes, ppos, tmp, len);
1986	}
1987
1988	static ssize_t cgroup_file_read(struct file file, char __user buf,
1989	size_t nbytes, loff_t *ppos)
1990	{
1991	struct cftype *cft = __d_cft(file->f_dentry);
1992	struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
1993
1994	if (cgroup_is_removed(cgrp))
1995	return -ENODEV;
1996
1997	if (cft->read)
1998	return cft->read(cgrp, cft, file, buf, nbytes, ppos);
1999	if (cft->read_u64)
2000	return cgroup_read_u64(cgrp, cft, file, buf, nbytes, ppos);
2001	if (cft->read_s64)
2002	return cgroup_read_s64(cgrp, cft, file, buf, nbytes, ppos);
2003	return -EINVAL;
2004	}
2005
2006	/*
2007	* seqfile ops/methods for returning structured data. Currently just
2008	* supports string->u64 maps, but can be extended in future.
2009	*/
2010
2011	struct cgroup_seqfile_state {
2012	struct cftype *cft;
2013	struct cgroup *cgroup;
2014	};
2015
2016	static int cgroup_map_add(struct cgroup_map_cb cb, const char key, u64 value)
2017	{
2018	struct seq_file *sf = cb->state;
2019	return seq_printf(sf, "%s %llu\n", key, (unsigned long long)value);
2020	}
2021
2022	static int cgroup_seqfile_show(struct seq_file m, void arg)
2023	{
2024	struct cgroup_seqfile_state *state = m->private;
2025	struct cftype *cft = state->cft;
2026	if (cft->read_map) {
2027	struct cgroup_map_cb cb = {
2028	.fill = cgroup_map_add,
2029	.state = m,
2030	};
2031	return cft->read_map(state->cgroup, cft, &cb);
2032	}
2033	return cft->read_seq_string(state->cgroup, cft, m);
2034	}
2035
2036	static int cgroup_seqfile_release(struct inode inode, struct file file)
2037	{
2038	struct seq_file *seq = file->private_data;
2039	kfree(seq->private);
2040	return single_release(inode, file);
2041	}
2042
2043	static const struct file_operations cgroup_seqfile_operations = {
2044	.read = seq_read,
2045	.write = cgroup_file_write,
2046	.llseek = seq_lseek,
2047	.release = cgroup_seqfile_release,
2048	};
2049
2050	static int cgroup_file_open(struct inode inode, struct file file)
2051	{
2052	int err;
2053	struct cftype *cft;
2054
2055	err = generic_file_open(inode, file);
2056	if (err)
2057	return err;
2058	cft = __d_cft(file->f_dentry);
2059
2060	if (cft->read_map \|\| cft->read_seq_string) {
2061	struct cgroup_seqfile_state *state =
2062	kzalloc(sizeof(*state), GFP_USER);
2063	if (!state)
2064	return -ENOMEM;
2065	state->cft = cft;
2066	state->cgroup = __d_cgrp(file->f_dentry->d_parent);
2067	file->f_op = &cgroup_seqfile_operations;
2068	err = single_open(file, cgroup_seqfile_show, state);
2069	if (err < 0)
2070	kfree(state);
2071	} else if (cft->open)
2072	err = cft->open(inode, file);
2073	else
2074	err = 0;
2075
2076	return err;
2077	}
2078
2079	static int cgroup_file_release(struct inode inode, struct file file)
2080	{
2081	struct cftype *cft = __d_cft(file->f_dentry);
2082	if (cft->release)
2083	return cft->release(inode, file);
2084	return 0;
2085	}
2086
2087	/*
2088	* cgroup_rename - Only allow simple rename of directories in place.
2089	*/
2090	static int cgroup_rename(struct inode old_dir, struct dentry old_dentry,
2091	struct inode new_dir, struct dentry new_dentry)
2092	{
2093	if (!S_ISDIR(old_dentry->d_inode->i_mode))
2094	return -ENOTDIR;
2095	if (new_dentry->d_inode)
2096	return -EEXIST;
2097	if (old_dir != new_dir)
2098	return -EIO;
2099	return simple_rename(old_dir, old_dentry, new_dir, new_dentry);
2100	}
2101
2102	static const struct file_operations cgroup_file_operations = {
2103	.read = cgroup_file_read,
2104	.write = cgroup_file_write,
2105	.llseek = generic_file_llseek,
2106	.open = cgroup_file_open,
2107	.release = cgroup_file_release,
2108	};
2109
2110	static const struct inode_operations cgroup_dir_inode_operations = {
2111	.lookup = simple_lookup,
2112	.mkdir = cgroup_mkdir,
2113	.rmdir = cgroup_rmdir,
2114	.rename = cgroup_rename,
2115	};
2116
2117	/*
2118	* Check if a file is a control file
2119	*/
2120	static inline struct cftype __file_cft(struct file file)
2121	{
2122	if (file->f_dentry->d_inode->i_fop != &cgroup_file_operations)
2123	return ERR_PTR(-EINVAL);
2124	return __d_cft(file->f_dentry);
2125	}
2126
2127	static int cgroup_create_file(struct dentry *dentry, mode_t mode,
2128	struct super_block *sb)
2129	{
2130	static const struct dentry_operations cgroup_dops = {
2131	.d_iput = cgroup_diput,
2132	};
2133
2134	struct inode *inode;
2135
2136	if (!dentry)
2137	return -ENOENT;
2138	if (dentry->d_inode)
2139	return -EEXIST;
2140
2141	inode = cgroup_new_inode(mode, sb);
2142	if (!inode)
2143	return -ENOMEM;
2144
2145	if (S_ISDIR(mode)) {
2146	inode->i_op = &cgroup_dir_inode_operations;
2147	inode->i_fop = &simple_dir_operations;
2148
2149	/* start off with i_nlink == 2 (for "." entry) */
2150	inc_nlink(inode);
2151
2152	/* start with the directory inode held, so that we can
2153	* populate it without racing with another mkdir */
2154	mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
2155	} else if (S_ISREG(mode)) {
2156	inode->i_size = 0;
2157	inode->i_fop = &cgroup_file_operations;
2158	}
2159	dentry->d_op = &cgroup_dops;
2160	d_instantiate(dentry, inode);
2161	dget(dentry); /* Extra count - pin the dentry in core */
2162	return 0;
2163	}
2164
2165	/*
2166	* cgroup_create_dir - create a directory for an object.
2167	* @cgrp: the cgroup we create the directory for. It must have a valid
2168	* ->parent field. And we are going to fill its ->dentry field.
2169	* @dentry: dentry of the new cgroup
2170	* @mode: mode to set on new directory.
2171	*/
2172	static int cgroup_create_dir(struct cgroup cgrp, struct dentry dentry,
2173	mode_t mode)
2174	{
2175	struct dentry *parent;
2176	int error = 0;
2177
2178	parent = cgrp->parent->dentry;
2179	error = cgroup_create_file(dentry, S_IFDIR \| mode, cgrp->root->sb);
2180	if (!error) {
2181	dentry->d_fsdata = cgrp;
2182	inc_nlink(parent->d_inode);
2183	rcu_assign_pointer(cgrp->dentry, dentry);
2184	dget(dentry);
2185	}
2186	dput(dentry);
2187
2188	return error;
2189	}
2190
2191	/**
2192	* cgroup_file_mode - deduce file mode of a control file
2193	* @cft: the control file in question
2194	*
2195	* returns cft->mode if ->mode is not 0
2196	* returns S_IRUGO\|S_IWUSR if it has both a read and a write handler
2197	* returns S_IRUGO if it has only a read handler
2198	* returns S_IWUSR if it has only a write hander
2199	*/
2200	static mode_t cgroup_file_mode(const struct cftype *cft)
2201	{
2202	mode_t mode = 0;
2203
2204	if (cft->mode)
2205	return cft->mode;
2206
2207	if (cft->read \|\| cft->read_u64 \|\| cft->read_s64 \|\|
2208	cft->read_map \|\| cft->read_seq_string)
2209	mode \|= S_IRUGO;
2210
2211	if (cft->write \|\| cft->write_u64 \|\| cft->write_s64 \|\|
2212	cft->write_string \|\| cft->trigger)
2213	mode \|= S_IWUSR;
2214
2215	return mode;
2216	}
2217
2218	int cgroup_add_file(struct cgroup *cgrp,
2219	struct cgroup_subsys *subsys,
2220	const struct cftype *cft)
2221	{
2222	struct dentry *dir = cgrp->dentry;
2223	struct dentry *dentry;
2224	int error;
2225	mode_t mode;
2226
2227	char name[MAX_CGROUP_TYPE_NAMELEN + MAX_CFTYPE_NAME + 2] = { 0 };
2228	if (subsys && !test_bit(ROOT_NOPREFIX, &cgrp->root->flags)) {
2229	strcpy(name, subsys->name);
2230	strcat(name, ".");
2231	}
2232	strcat(name, cft->name);
2233	BUG_ON(!mutex_is_locked(&dir->d_inode->i_mutex));
2234	dentry = lookup_one_len(name, dir, strlen(name));
2235	if (!IS_ERR(dentry)) {
2236	mode = cgroup_file_mode(cft);
2237	error = cgroup_create_file(dentry, mode \| S_IFREG,
2238	cgrp->root->sb);
2239	if (!error)
2240	dentry->d_fsdata = (void *)cft;
2241	dput(dentry);
2242	} else
2243	error = PTR_ERR(dentry);
2244	return error;
2245	}
2246	EXPORT_SYMBOL_GPL(cgroup_add_file);
2247
2248	int cgroup_add_files(struct cgroup *cgrp,
2249	struct cgroup_subsys *subsys,
2250	const struct cftype cft[],
2251	int count)
2252	{
2253	int i, err;
2254	for (i = 0; i < count; i++) {
2255	err = cgroup_add_file(cgrp, subsys, &cft[i]);
2256	if (err)
2257	return err;
2258	}
2259	return 0;
2260	}
2261	EXPORT_SYMBOL_GPL(cgroup_add_files);
2262
2263	/**
2264	* cgroup_task_count - count the number of tasks in a cgroup.
2265	* @cgrp: the cgroup in question
2266	*
2267	* Return the number of tasks in the cgroup.
2268	*/
2269	int cgroup_task_count(const struct cgroup *cgrp)
2270	{
2271	int count = 0;
2272	struct cg_cgroup_link *link;
2273
2274	read_lock(&css_set_lock);
2275	list_for_each_entry(link, &cgrp->css_sets, cgrp_link_list) {
2276	count += atomic_read(&link->cg->refcount);
2277	}
2278	read_unlock(&css_set_lock);
2279	return count;
2280	}
2281
2282	/*
2283	* Advance a list_head iterator. The iterator should be positioned at
2284	* the start of a css_set
2285	*/
2286	static void cgroup_advance_iter(struct cgroup *cgrp,
2287	struct cgroup_iter *it)
2288	{
2289	struct list_head *l = it->cg_link;
2290	struct cg_cgroup_link *link;
2291	struct css_set *cg;
2292
2293	/* Advance to the next non-empty css_set */
2294	do {
2295	l = l->next;
2296	if (l == &cgrp->css_sets) {
2297	it->cg_link = NULL;
2298	return;
2299	}
2300	link = list_entry(l, struct cg_cgroup_link, cgrp_link_list);
2301	cg = link->cg;
2302	} while (list_empty(&cg->tasks));
2303	it->cg_link = l;
2304	it->task = cg->tasks.next;
2305	}
2306
2307	/*
2308	* To reduce the fork() overhead for systems that are not actually
2309	* using their cgroups capability, we don't maintain the lists running
2310	* through each css_set to its tasks until we see the list actually
2311	* used - in other words after the first call to cgroup_iter_start().
2312	*
2313	* The tasklist_lock is not held here, as do_each_thread() and
2314	* while_each_thread() are protected by RCU.
2315	*/
2316	static void cgroup_enable_task_cg_lists(void)
2317	{
2318	struct task_struct p, g;
2319	write_lock(&css_set_lock);
2320	use_task_css_set_links = 1;
2321	do_each_thread(g, p) {
2322	task_lock(p);
2323	/*
2324	* We should check if the process is exiting, otherwise
2325	* it will race with cgroup_exit() in that the list
2326	* entry won't be deleted though the process has exited.
2327	*/
2328	if (!(p->flags & PF_EXITING) && list_empty(&p->cg_list))
2329	list_add(&p->cg_list, &p->cgroups->tasks);
2330	task_unlock(p);
2331	} while_each_thread(g, p);
2332	write_unlock(&css_set_lock);
2333	}
2334
2335	void cgroup_iter_start(struct cgroup cgrp, struct cgroup_iter it)
2336	{
2337	/*
2338	* The first time anyone tries to iterate across a cgroup,
2339	* we need to enable the list linking each css_set to its
2340	* tasks, and fix up all existing tasks.
2341	*/
2342	if (!use_task_css_set_links)
2343	cgroup_enable_task_cg_lists();
2344
2345	read_lock(&css_set_lock);
2346	it->cg_link = &cgrp->css_sets;
2347	cgroup_advance_iter(cgrp, it);
2348	}
2349
2350	struct task_struct cgroup_iter_next(struct cgroup cgrp,
2351	struct cgroup_iter *it)
2352	{
2353	struct task_struct *res;
2354	struct list_head *l = it->task;
2355	struct cg_cgroup_link *link;
2356
2357	/* If the iterator cg is NULL, we have no tasks */
2358	if (!it->cg_link)
2359	return NULL;
2360	res = list_entry(l, struct task_struct, cg_list);
2361	/* Advance iterator to find next entry */
2362	l = l->next;
2363	link = list_entry(it->cg_link, struct cg_cgroup_link, cgrp_link_list);
2364	if (l == &link->cg->tasks) {
2365	/* We reached the end of this task list - move on to
2366	* the next cg_cgroup_link */
2367	cgroup_advance_iter(cgrp, it);
2368	} else {
2369	it->task = l;
2370	}
2371	return res;
2372	}
2373
2374	void cgroup_iter_end(struct cgroup cgrp, struct cgroup_iter it)
2375	{
2376	read_unlock(&css_set_lock);
2377	}
2378
2379	static inline int started_after_time(struct task_struct *t1,
2380	struct timespec *time,
2381	struct task_struct *t2)
2382	{
2383	int start_diff = timespec_compare(&t1->start_time, time);
2384	if (start_diff > 0) {
2385	return 1;
2386	} else if (start_diff < 0) {
2387	return 0;
2388	} else {
2389	/*
2390	* Arbitrarily, if two processes started at the same
2391	* time, we'll say that the lower pointer value
2392	* started first. Note that t2 may have exited by now
2393	* so this may not be a valid pointer any longer, but
2394	* that's fine - it still serves to distinguish
2395	* between two tasks started (effectively) simultaneously.
2396	*/
2397	return t1 > t2;
2398	}
2399	}
2400
2401	/*
2402	* This function is a callback from heap_insert() and is used to order
2403	* the heap.
2404	* In this case we order the heap in descending task start time.
2405	*/
2406	static inline int started_after(void p1, void p2)
2407	{
2408	struct task_struct *t1 = p1;
2409	struct task_struct *t2 = p2;
2410	return started_after_time(t1, &t2->start_time, t2);
2411	}
2412
2413	/**
2414	* cgroup_scan_tasks - iterate though all the tasks in a cgroup
2415	* @scan: struct cgroup_scanner containing arguments for the scan
2416	*
2417	* Arguments include pointers to callback functions test_task() and
2418	* process_task().
2419	* Iterate through all the tasks in a cgroup, calling test_task() for each,
2420	* and if it returns true, call process_task() for it also.
2421	* The test_task pointer may be NULL, meaning always true (select all tasks).
2422	* Effectively duplicates cgroup_iter_{start,next,end}()
2423	* but does not lock css_set_lock for the call to process_task().
2424	* The struct cgroup_scanner may be embedded in any structure of the caller's
2425	* creation.
2426	* It is guaranteed that process_task() will act on every task that
2427	* is a member of the cgroup for the duration of this call. This
2428	* function may or may not call process_task() for tasks that exit
2429	* or move to a different cgroup during the call, or are forked or
2430	* move into the cgroup during the call.
2431	*
2432	* Note that test_task() may be called with locks held, and may in some
2433	* situations be called multiple times for the same task, so it should
2434	* be cheap.
2435	* If the heap pointer in the struct cgroup_scanner is non-NULL, a heap has been
2436	* pre-allocated and will be used for heap operations (and its "gt" member will
2437	* be overwritten), else a temporary heap will be used (allocation of which
2438	* may cause this function to fail).
2439	*/
2440	int cgroup_scan_tasks(struct cgroup_scanner *scan)
2441	{
2442	int retval, i;
2443	struct cgroup_iter it;
2444	struct task_struct p, dropped;
2445	/* Never dereference latest_task, since it's not refcounted */
2446	struct task_struct *latest_task = NULL;
2447	struct ptr_heap tmp_heap;
2448	struct ptr_heap *heap;
2449	struct timespec latest_time = { 0, 0 };
2450
2451	if (scan->heap) {
2452	/* The caller supplied our heap and pre-allocated its memory */
2453	heap = scan->heap;
2454	heap->gt = &started_after;
2455	} else {
2456	/* We need to allocate our own heap memory */
2457	heap = &tmp_heap;
2458	retval = heap_init(heap, PAGE_SIZE, GFP_KERNEL, &started_after);
2459	if (retval)
2460	/* cannot allocate the heap */
2461	return retval;
2462	}
2463
2464	again:
2465	/*
2466	* Scan tasks in the cgroup, using the scanner's "test_task" callback
2467	* to determine which are of interest, and using the scanner's
2468	* "process_task" callback to process any of them that need an update.
2469	* Since we don't want to hold any locks during the task updates,
2470	* gather tasks to be processed in a heap structure.
2471	* The heap is sorted by descending task start time.
2472	* If the statically-sized heap fills up, we overflow tasks that
2473	* started later, and in future iterations only consider tasks that
2474	* started after the latest task in the previous pass. This
2475	* guarantees forward progress and that we don't miss any tasks.
2476	*/
2477	heap->size = 0;
2478	cgroup_iter_start(scan->cg, &it);
2479	while ((p = cgroup_iter_next(scan->cg, &it))) {
2480	/*
2481	* Only affect tasks that qualify per the caller's callback,
2482	* if he provided one
2483	*/
2484	if (scan->test_task && !scan->test_task(p, scan))
2485	continue;
2486	/*
2487	* Only process tasks that started after the last task
2488	* we processed
2489	*/
2490	if (!started_after_time(p, &latest_time, latest_task))
2491	continue;
2492	dropped = heap_insert(heap, p);
2493	if (dropped == NULL) {
2494	/*
2495	* The new task was inserted; the heap wasn't
2496	* previously full
2497	*/
2498	get_task_struct(p);
2499	} else if (dropped != p) {
2500	/*
2501	* The new task was inserted, and pushed out a
2502	* different task
2503	*/
2504	get_task_struct(p);
2505	put_task_struct(dropped);
2506	}
2507	/*
2508	* Else the new task was newer than anything already in
2509	* the heap and wasn't inserted
2510	*/
2511	}
2512	cgroup_iter_end(scan->cg, &it);
2513
2514	if (heap->size) {
2515	for (i = 0; i < heap->size; i++) {
2516	struct task_struct *q = heap->ptrs[i];
2517	if (i == 0) {
2518	latest_time = q->start_time;
2519	latest_task = q;
2520	}
2521	/* Process the task per the caller's callback */
2522	scan->process_task(q, scan);
2523	put_task_struct(q);
2524	}
2525	/*
2526	* If we had to process any tasks at all, scan again
2527	* in case some of them were in the middle of forking
2528	* children that didn't get processed.
2529	* Not the most efficient way to do it, but it avoids
2530	* having to take callback_mutex in the fork path
2531	*/
2532	goto again;
2533	}
2534	if (heap == &tmp_heap)
2535	heap_free(&tmp_heap);
2536	return 0;
2537	}
2538
2539	/*
2540	* Stuff for reading the 'tasks'/'procs' files.
2541	*
2542	* Reading this file can return large amounts of data if a cgroup has
2543	* lots of attached tasks. So it may need several calls to read(),
2544	* but we cannot guarantee that the information we produce is correct
2545	* unless we produce it entirely atomically.
2546	*
2547	*/
2548
2549	/*
2550	* The following two functions "fix" the issue where there are more pids
2551	* than kmalloc will give memory for; in such cases, we use vmalloc/vfree.
2552	* TODO: replace with a kernel-wide solution to this problem
2553	*/
2554	#define PIDLIST_TOO_LARGE(c) ((c) * sizeof(pid_t) > (PAGE_SIZE * 2))
2555	static void *pidlist_allocate(int count)
2556	{
2557	if (PIDLIST_TOO_LARGE(count))
2558	return vmalloc(count * sizeof(pid_t));
2559	else
2560	return kmalloc(count * sizeof(pid_t), GFP_KERNEL);
2561	}
2562	static void pidlist_free(void *p)
2563	{
2564	if (is_vmalloc_addr(p))
2565	vfree(p);
2566	else
2567	kfree(p);
2568	}
2569	static void pidlist_resize(void p, int newcount)
2570	{
2571	void *newlist;
2572	/* note: if new alloc fails, old p will still be valid either way */
2573	if (is_vmalloc_addr(p)) {
2574	newlist = vmalloc(newcount * sizeof(pid_t));
2575	if (!newlist)
2576	return NULL;
2577	memcpy(newlist, p, newcount * sizeof(pid_t));
2578	vfree(p);
2579	} else {
2580	newlist = krealloc(p, newcount * sizeof(pid_t), GFP_KERNEL);
2581	}
2582	return newlist;
2583	}
2584
2585	/*
2586	* pidlist_uniq - given a kmalloc()ed list, strip out all duplicate entries
2587	* If the new stripped list is sufficiently smaller and there's enough memory
2588	* to allocate a new buffer, will let go of the unneeded memory. Returns the
2589	* number of unique elements.
2590	*/
2591	/* is the size difference enough that we should re-allocate the array? */
2592	#define PIDLIST_REALLOC_DIFFERENCE(old, new) ((old) - PAGE_SIZE >= (new))
2593	static int pidlist_uniq(pid_t **p, int length)
2594	{
2595	int src, dest = 1;
2596	pid_t list = p;
2597	pid_t *newlist;
2598
2599	/*
2600	* we presume the 0th element is unique, so i starts at 1. trivial
2601	* edge cases first; no work needs to be done for either
2602	*/
2603	if (length == 0 \|\| length == 1)
2604	return length;
2605	/* src and dest walk down the list; dest counts unique elements */
2606	for (src = 1; src < length; src++) {
2607	/* find next unique element */
2608	while (list[src] == list[src-1]) {
2609	src++;
2610	if (src == length)
2611	goto after;
2612	}
2613	/* dest always points to where the next unique element goes */
2614	list[dest] = list[src];
2615	dest++;
2616	}
2617	after:
2618	/*
2619	* if the length difference is large enough, we want to allocate a
2620	* smaller buffer to save memory. if this fails due to out of memory,
2621	* we'll just stay with what we've got.
2622	*/
2623	if (PIDLIST_REALLOC_DIFFERENCE(length, dest)) {
2624	newlist = pidlist_resize(list, dest);
2625	if (newlist)
2626	*p = newlist;
2627	}
2628	return dest;
2629	}
2630
2631	static int cmppid(const void a, const void b)
2632	{
2633	return (pid_t )a - (pid_t )b;
2634	}
2635
2636	/*
2637	* find the appropriate pidlist for our purpose (given procs vs tasks)
2638	* returns with the lock on that pidlist already held, and takes care
2639	* of the use count, or returns NULL with no locks held if we're out of
2640	* memory.
2641	*/
2642	static struct cgroup_pidlist cgroup_pidlist_find(struct cgroup cgrp,
2643	enum cgroup_filetype type)
2644	{
2645	struct cgroup_pidlist *l;
2646	/* don't need task_nsproxy() if we're looking at ourself */
2647	struct pid_namespace *ns = current->nsproxy->pid_ns;
2648
2649	/*
2650	* We can't drop the pidlist_mutex before taking the l->mutex in case
2651	* the last ref-holder is trying to remove l from the list at the same
2652	* time. Holding the pidlist_mutex precludes somebody taking whichever
2653	* list we find out from under us - compare release_pid_array().
2654	*/
2655	mutex_lock(&cgrp->pidlist_mutex);
2656	list_for_each_entry(l, &cgrp->pidlists, links) {
2657	if (l->key.type == type && l->key.ns == ns) {
2658	/* make sure l doesn't vanish out from under us */
2659	down_write(&l->mutex);
2660	mutex_unlock(&cgrp->pidlist_mutex);
2661	return l;
2662	}
2663	}
2664	/* entry not found; create a new one */
2665	l = kmalloc(sizeof(struct cgroup_pidlist), GFP_KERNEL);
2666	if (!l) {
2667	mutex_unlock(&cgrp->pidlist_mutex);
2668	return l;
2669	}
2670	init_rwsem(&l->mutex);
2671	down_write(&l->mutex);
2672	l->key.type = type;
2673	l->key.ns = get_pid_ns(ns);
2674	l->use_count = 0; /* don't increment here */
2675	l->list = NULL;
2676	l->owner = cgrp;
2677	list_add(&l->links, &cgrp->pidlists);
2678	mutex_unlock(&cgrp->pidlist_mutex);
2679	return l;
2680	}
2681
2682	/*
2683	* Load a cgroup's pidarray with either procs' tgids or tasks' pids
2684	*/
2685	static int pidlist_array_load(struct cgroup *cgrp, enum cgroup_filetype type,
2686	struct cgroup_pidlist **lp)
2687	{
2688	pid_t *array;
2689	int length;
2690	int pid, n = 0; /* used for populating the array */
2691	struct cgroup_iter it;
2692	struct task_struct *tsk;
2693	struct cgroup_pidlist *l;
2694
2695	/*
2696	* If cgroup gets more users after we read count, we won't have
2697	* enough space - tough. This race is indistinguishable to the
2698	* caller from the case that the additional cgroup users didn't
2699	* show up until sometime later on.
2700	*/
2701	length = cgroup_task_count(cgrp);
2702	array = pidlist_allocate(length);
2703	if (!array)
2704	return -ENOMEM;
2705	/* now, populate the array */
2706	cgroup_iter_start(cgrp, &it);
2707	while ((tsk = cgroup_iter_next(cgrp, &it))) {
2708	if (unlikely(n == length))
2709	break;
2710	/* get tgid or pid for procs or tasks file respectively */
2711	if (type == CGROUP_FILE_PROCS)
2712	pid = task_tgid_vnr(tsk);
2713	else
2714	pid = task_pid_vnr(tsk);
2715	if (pid > 0) /* make sure to only use valid results */
2716	array[n++] = pid;
2717	}
2718	cgroup_iter_end(cgrp, &it);
2719	length = n;
2720	/* now sort & (if procs) strip out duplicates */
2721	sort(array, length, sizeof(pid_t), cmppid, NULL);
2722	if (type == CGROUP_FILE_PROCS)
2723	length = pidlist_uniq(&array, length);
2724	l = cgroup_pidlist_find(cgrp, type);
2725	if (!l) {
2726	pidlist_free(array);
2727	return -ENOMEM;
2728	}
2729	/* store array, freeing old if necessary - lock already held */
2730	pidlist_free(l->list);
2731	l->list = array;
2732	l->length = length;
2733	l->use_count++;
2734	up_write(&l->mutex);
2735	*lp = l;
2736	return 0;
2737	}
2738
2739	/**
2740	* cgroupstats_build - build and fill cgroupstats
2741	* @stats: cgroupstats to fill information into
2742	* @dentry: A dentry entry belonging to the cgroup for which stats have
2743	* been requested.
2744	*
2745	* Build and fill cgroupstats so that taskstats can export it to user
2746	* space.
2747	*/
2748	int cgroupstats_build(struct cgroupstats stats, struct dentry dentry)
2749	{
2750	int ret = -EINVAL;
2751	struct cgroup *cgrp;
2752	struct cgroup_iter it;
2753	struct task_struct *tsk;
2754
2755	/*
2756	* Validate dentry by checking the superblock operations,
2757	* and make sure it's a directory.
2758	*/
2759	if (dentry->d_sb->s_op != &cgroup_ops \|\|
2760	!S_ISDIR(dentry->d_inode->i_mode))
2761	goto err;
2762
2763	ret = 0;
2764	cgrp = dentry->d_fsdata;
2765
2766	cgroup_iter_start(cgrp, &it);
2767	while ((tsk = cgroup_iter_next(cgrp, &it))) {
2768	switch (tsk->state) {
2769	case TASK_RUNNING:
2770	stats->nr_running++;
2771	break;
2772	case TASK_INTERRUPTIBLE:
2773	stats->nr_sleeping++;
2774	break;
2775	case TASK_UNINTERRUPTIBLE:
2776	stats->nr_uninterruptible++;
2777	break;
2778	case TASK_STOPPED:
2779	stats->nr_stopped++;
2780	break;
2781	default:
2782	if (delayacct_is_task_waiting_on_io(tsk))
2783	stats->nr_io_wait++;
2784	break;
2785	}
2786	}
2787	cgroup_iter_end(cgrp, &it);
2788
2789	err:
2790	return ret;
2791	}
2792
2793
2794	/*
2795	* seq_file methods for the tasks/procs files. The seq_file position is the
2796	* next pid to display; the seq_file iterator is a pointer to the pid
2797	* in the cgroup->l->list array.
2798	*/
2799
2800	static void cgroup_pidlist_start(struct seq_file s, loff_t *pos)
2801	{
2802	/*
2803	* Initially we receive a position value that corresponds to
2804	* one more than the last pid shown (or 0 on the first call or
2805	* after a seek to the start). Use a binary-search to find the
2806	* next pid to display, if any
2807	*/
2808	struct cgroup_pidlist *l = s->private;
2809	int index = 0, pid = *pos;
2810	int *iter;
2811
2812	down_read(&l->mutex);
2813	if (pid) {
2814	int end = l->length;
2815
2816	while (index < end) {
2817	int mid = (index + end) / 2;
2818	if (l->list[mid] == pid) {
2819	index = mid;
2820	break;
2821	} else if (l->list[mid] <= pid)
2822	index = mid + 1;
2823	else
2824	end = mid;
2825	}
2826	}
2827	/* If we're off the end of the array, we're done */
2828	if (index >= l->length)
2829	return NULL;
2830	/* Update the abstract position to be the actual pid that we found */
2831	iter = l->list + index;
2832	pos = iter;
2833	return iter;
2834	}
2835
2836	static void cgroup_pidlist_stop(struct seq_file s, void v)
2837	{
2838	struct cgroup_pidlist *l = s->private;
2839	up_read(&l->mutex);
2840	}
2841
2842	static void cgroup_pidlist_next(struct seq_file s, void v, loff_t pos)
2843	{
2844	struct cgroup_pidlist *l = s->private;
2845	pid_t *p = v;
2846	pid_t *end = l->list + l->length;
2847	/*
2848	* Advance to the next pid in the array. If this goes off the
2849	* end, we're done
2850	*/
2851	p++;
2852	if (p >= end) {
2853	return NULL;
2854	} else {
2855	pos = p;
2856	return p;
2857	}
2858	}
2859
2860	static int cgroup_pidlist_show(struct seq_file s, void v)
2861	{
2862	return seq_printf(s, "%d\n", (int )v);
2863	}
2864
2865	/*
2866	* seq_operations functions for iterating on pidlists through seq_file -
2867	* independent of whether it's tasks or procs
2868	*/
2869	static const struct seq_operations cgroup_pidlist_seq_operations = {
2870	.start = cgroup_pidlist_start,
2871	.stop = cgroup_pidlist_stop,
2872	.next = cgroup_pidlist_next,
2873	.show = cgroup_pidlist_show,
2874	};
2875
2876	static void cgroup_release_pid_array(struct cgroup_pidlist *l)
2877	{
2878	/*
2879	* the case where we're the last user of this particular pidlist will
2880	* have us remove it from the cgroup's list, which entails taking the
2881	* mutex. since in pidlist_find the pidlist->lock depends on cgroup->
2882	* pidlist_mutex, we have to take pidlist_mutex first.
2883	*/
2884	mutex_lock(&l->owner->pidlist_mutex);
2885	down_write(&l->mutex);
2886	BUG_ON(!l->use_count);
2887	if (!--l->use_count) {
2888	/* we're the last user if refcount is 0; remove and free */
2889	list_del(&l->links);
2890	mutex_unlock(&l->owner->pidlist_mutex);
2891	pidlist_free(l->list);
2892	put_pid_ns(l->key.ns);
2893	up_write(&l->mutex);
2894	kfree(l);
2895	return;
2896	}
2897	mutex_unlock(&l->owner->pidlist_mutex);
2898	up_write(&l->mutex);
2899	}
2900
2901	static int cgroup_pidlist_release(struct inode inode, struct file file)
2902	{
2903	struct cgroup_pidlist *l;
2904	if (!(file->f_mode & FMODE_READ))
2905	return 0;
2906	/*
2907	* the seq_file will only be initialized if the file was opened for
2908	* reading; hence we check if it's not null only in that case.
2909	*/
2910	l = ((struct seq_file *)file->private_data)->private;
2911	cgroup_release_pid_array(l);
2912	return seq_release(inode, file);
2913	}
2914
2915	static const struct file_operations cgroup_pidlist_operations = {
2916	.read = seq_read,
2917	.llseek = seq_lseek,
2918	.write = cgroup_file_write,
2919	.release = cgroup_pidlist_release,
2920	};
2921
2922	/*
2923	* The following functions handle opens on a file that displays a pidlist
2924	* (tasks or procs). Prepare an array of the process/thread IDs of whoever's
2925	* in the cgroup.
2926	*/
2927	/* helper function for the two below it */
2928	static int cgroup_pidlist_open(struct file *file, enum cgroup_filetype type)
2929	{
2930	struct cgroup *cgrp = __d_cgrp(file->f_dentry->d_parent);
2931	struct cgroup_pidlist *l;
2932	int retval;
2933
2934	/* Nothing to do for write-only files */
2935	if (!(file->f_mode & FMODE_READ))
2936	return 0;
2937
2938	/* have the array populated */
2939	retval = pidlist_array_load(cgrp, type, &l);
2940	if (retval)
2941	return retval;
2942	/* configure file information */
2943	file->f_op = &cgroup_pidlist_operations;
2944
2945	retval = seq_open(file, &cgroup_pidlist_seq_operations);
2946	if (retval) {
2947	cgroup_release_pid_array(l);
2948	return retval;
2949	}
2950	((struct seq_file *)file->private_data)->private = l;
2951	return 0;
2952	}
2953	static int cgroup_tasks_open(struct inode unused, struct file file)
2954	{
2955	return cgroup_pidlist_open(file, CGROUP_FILE_TASKS);
2956	}
2957	static int cgroup_procs_open(struct inode unused, struct file file)
2958	{
2959	return cgroup_pidlist_open(file, CGROUP_FILE_PROCS);
2960	}
2961
2962	static u64 cgroup_read_notify_on_release(struct cgroup *cgrp,
2963	struct cftype *cft)
2964	{
2965	return notify_on_release(cgrp);
2966	}
2967
2968	static int cgroup_write_notify_on_release(struct cgroup *cgrp,
2969	struct cftype *cft,
2970	u64 val)
2971	{
2972	clear_bit(CGRP_RELEASABLE, &cgrp->flags);
2973	if (val)
2974	set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
2975	else
2976	clear_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
2977	return 0;
2978	}
2979
2980	/*
2981	* Unregister event and free resources.
2982	*
2983	* Gets called from workqueue.
2984	*/
2985	static void cgroup_event_remove(struct work_struct *work)
2986	{
2987	struct cgroup_event *event = container_of(work, struct cgroup_event,
2988	remove);
2989	struct cgroup *cgrp = event->cgrp;
2990
2991	/* TODO: check return code */
2992	event->cft->unregister_event(cgrp, event->cft, event->eventfd);
2993
2994	eventfd_ctx_put(event->eventfd);
2995	kfree(event);
2996	dput(cgrp->dentry);
2997	}
2998
2999	/*
3000	* Gets called on POLLHUP on eventfd when user closes it.
3001	*
3002	* Called with wqh->lock held and interrupts disabled.
3003	*/
3004	static int cgroup_event_wake(wait_queue_t *wait, unsigned mode,
3005	int sync, void *key)
3006	{
3007	struct cgroup_event *event = container_of(wait,
3008	struct cgroup_event, wait);
3009	struct cgroup *cgrp = event->cgrp;
3010	unsigned long flags = (unsigned long)key;
3011
3012	if (flags & POLLHUP) {
3013	remove_wait_queue_locked(event->wqh, &event->wait);
3014	spin_lock(&cgrp->event_list_lock);
3015	list_del(&event->list);
3016	spin_unlock(&cgrp->event_list_lock);
3017	/*
3018	* We are in atomic context, but cgroup_event_remove() may
3019	* sleep, so we have to call it in workqueue.
3020	*/
3021	schedule_work(&event->remove);
3022	}
3023
3024	return 0;
3025	}
3026
3027	static void cgroup_event_ptable_queue_proc(struct file *file,
3028	wait_queue_head_t wqh, poll_table pt)
3029	{
3030	struct cgroup_event *event = container_of(pt,
3031	struct cgroup_event, pt);
3032
3033	event->wqh = wqh;
3034	add_wait_queue(wqh, &event->wait);
3035	}
3036
3037	/*
3038	* Parse input and register new cgroup event handler.
3039	*
3040	* Input must be in format '<event_fd> <control_fd> <args>'.
3041	* Interpretation of args is defined by control file implementation.
3042	*/
3043	static int cgroup_write_event_control(struct cgroup cgrp, struct cftype cft,
3044	const char *buffer)
3045	{
3046	struct cgroup_event *event = NULL;
3047	unsigned int efd, cfd;
3048	struct file *efile = NULL;
3049	struct file *cfile = NULL;
3050	char *endp;
3051	int ret;
3052
3053	efd = simple_strtoul(buffer, &endp, 10);
3054	if (*endp != ' ')
3055	return -EINVAL;
3056	buffer = endp + 1;
3057
3058	cfd = simple_strtoul(buffer, &endp, 10);
3059	if ((endp != ' ') && (endp != '\0'))
3060	return -EINVAL;
3061	buffer = endp + 1;
3062
3063	event = kzalloc(sizeof(*event), GFP_KERNEL);
3064	if (!event)
3065	return -ENOMEM;
3066	event->cgrp = cgrp;
3067	INIT_LIST_HEAD(&event->list);
3068	init_poll_funcptr(&event->pt, cgroup_event_ptable_queue_proc);
3069	init_waitqueue_func_entry(&event->wait, cgroup_event_wake);
3070	INIT_WORK(&event->remove, cgroup_event_remove);
3071
3072	efile = eventfd_fget(efd);
3073	if (IS_ERR(efile)) {
3074	ret = PTR_ERR(efile);
3075	goto fail;
3076	}
3077
3078	event->eventfd = eventfd_ctx_fileget(efile);
3079	if (IS_ERR(event->eventfd)) {
3080	ret = PTR_ERR(event->eventfd);
3081	goto fail;
3082	}
3083
3084	cfile = fget(cfd);
3085	if (!cfile) {
3086	ret = -EBADF;
3087	goto fail;
3088	}
3089
3090	/* the process need read permission on control file */
3091	ret = file_permission(cfile, MAY_READ);
3092	if (ret < 0)
3093	goto fail;
3094
3095	event->cft = __file_cft(cfile);
3096	if (IS_ERR(event->cft)) {
3097	ret = PTR_ERR(event->cft);
3098	goto fail;
3099	}
3100
3101	if (!event->cft->register_event \|\| !event->cft->unregister_event) {
3102	ret = -EINVAL;
3103	goto fail;
3104	}
3105
3106	ret = event->cft->register_event(cgrp, event->cft,
3107	event->eventfd, buffer);
3108	if (ret)
3109	goto fail;
3110
3111	if (efile->f_op->poll(efile, &event->pt) & POLLHUP) {
3112	event->cft->unregister_event(cgrp, event->cft, event->eventfd);
3113	ret = 0;
3114	goto fail;
3115	}
3116
3117	/*
3118	* Events should be removed after rmdir of cgroup directory, but before
3119	* destroying subsystem state objects. Let's take reference to cgroup
3120	* directory dentry to do that.
3121	*/
3122	dget(cgrp->dentry);
3123
3124	spin_lock(&cgrp->event_list_lock);
3125	list_add(&event->list, &cgrp->event_list);
3126	spin_unlock(&cgrp->event_list_lock);
3127
3128	fput(cfile);
3129	fput(efile);
3130
3131	return 0;
3132
3133	fail:
3134	if (cfile)
3135	fput(cfile);
3136
3137	if (event && event->eventfd && !IS_ERR(event->eventfd))
3138	eventfd_ctx_put(event->eventfd);
3139
3140	if (!IS_ERR_OR_NULL(efile))
3141	fput(efile);
3142
3143	kfree(event);
3144
3145	return ret;
3146	}
3147
3148	/*
3149	* for the common functions, 'private' gives the type of file
3150	*/
3151	/* for hysterical raisins, we can't put this on the older files */
3152	#define CGROUP_FILE_GENERIC_PREFIX "cgroup."
3153	static struct cftype files[] = {
3154	{
3155	.name = "tasks",
3156	.open = cgroup_tasks_open,
3157	.write_u64 = cgroup_tasks_write,
3158	.release = cgroup_pidlist_release,
3159	.mode = S_IRUGO \| S_IWUSR,
3160	},
3161	{
3162	.name = CGROUP_FILE_GENERIC_PREFIX "procs",
3163	.open = cgroup_procs_open,
3164	/* .write_u64 = cgroup_procs_write, TODO */
3165	.release = cgroup_pidlist_release,
3166	.mode = S_IRUGO,
3167	},
3168	{
3169	.name = "notify_on_release",
3170	.read_u64 = cgroup_read_notify_on_release,
3171	.write_u64 = cgroup_write_notify_on_release,
3172	},
3173	{
3174	.name = CGROUP_FILE_GENERIC_PREFIX "event_control",
3175	.write_string = cgroup_write_event_control,
3176	.mode = S_IWUGO,
3177	},
3178	};
3179
3180	static struct cftype cft_release_agent = {
3181	.name = "release_agent",
3182	.read_seq_string = cgroup_release_agent_show,
3183	.write_string = cgroup_release_agent_write,
3184	.max_write_len = PATH_MAX,
3185	};
3186
3187	static int cgroup_populate_dir(struct cgroup *cgrp)
3188	{
3189	int err;
3190	struct cgroup_subsys *ss;
3191
3192	/* First clear out any existing files */
3193	cgroup_clear_directory(cgrp->dentry);
3194
3195	err = cgroup_add_files(cgrp, NULL, files, ARRAY_SIZE(files));
3196	if (err < 0)
3197	return err;
3198
3199	if (cgrp == cgrp->top_cgroup) {
3200	if ((err = cgroup_add_file(cgrp, NULL, &cft_release_agent)) < 0)
3201	return err;
3202	}
3203
3204	for_each_subsys(cgrp->root, ss) {
3205	if (ss->populate && (err = ss->populate(ss, cgrp)) < 0)
3206	return err;
3207	}
3208	/* This cgroup is ready now */
3209	for_each_subsys(cgrp->root, ss) {
3210	struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
3211	/*
3212	* Update id->css pointer and make this css visible from
3213	* CSS ID functions. This pointer will be dereferened
3214	* from RCU-read-side without locks.
3215	*/
3216	if (css->id)
3217	rcu_assign_pointer(css->id->css, css);
3218	}
3219
3220	return 0;
3221	}
3222
3223	static void init_cgroup_css(struct cgroup_subsys_state *css,
3224	struct cgroup_subsys *ss,
3225	struct cgroup *cgrp)
3226	{
3227	css->cgroup = cgrp;
3228	atomic_set(&css->refcnt, 1);
3229	css->flags = 0;
3230	css->id = NULL;
3231	if (cgrp == dummytop)
3232	set_bit(CSS_ROOT, &css->flags);
3233	BUG_ON(cgrp->subsys[ss->subsys_id]);
3234	cgrp->subsys[ss->subsys_id] = css;
3235	}
3236
3237	static void cgroup_lock_hierarchy(struct cgroupfs_root *root)
3238	{
3239	/* We need to take each hierarchy_mutex in a consistent order */
3240	int i;
3241
3242	/*
3243	* No worry about a race with rebind_subsystems that might mess up the
3244	* locking order, since both parties are under cgroup_mutex.
3245	*/
3246	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
3247	struct cgroup_subsys *ss = subsys[i];
3248	if (ss == NULL)
3249	continue;
3250	if (ss->root == root)
3251	mutex_lock(&ss->hierarchy_mutex);
3252	}
3253	}
3254
3255	static void cgroup_unlock_hierarchy(struct cgroupfs_root *root)
3256	{
3257	int i;
3258
3259	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
3260	struct cgroup_subsys *ss = subsys[i];
3261	if (ss == NULL)
3262	continue;
3263	if (ss->root == root)
3264	mutex_unlock(&ss->hierarchy_mutex);
3265	}
3266	}
3267
3268	/*
3269	* cgroup_create - create a cgroup
3270	* @parent: cgroup that will be parent of the new cgroup
3271	* @dentry: dentry of the new cgroup
3272	* @mode: mode to set on new inode
3273	*
3274	* Must be called with the mutex on the parent inode held
3275	*/
3276	static long cgroup_create(struct cgroup parent, struct dentry dentry,
3277	mode_t mode)
3278	{
3279	struct cgroup *cgrp;
3280	struct cgroupfs_root *root = parent->root;
3281	int err = 0;
3282	struct cgroup_subsys *ss;
3283	struct super_block *sb = root->sb;
3284
3285	cgrp = kzalloc(sizeof(*cgrp), GFP_KERNEL);
3286	if (!cgrp)
3287	return -ENOMEM;
3288
3289	/* Grab a reference on the superblock so the hierarchy doesn't
3290	* get deleted on unmount if there are child cgroups. This
3291	* can be done outside cgroup_mutex, since the sb can't
3292	* disappear while someone has an open control file on the
3293	* fs */
3294	atomic_inc(&sb->s_active);
3295
3296	mutex_lock(&cgroup_mutex);
3297
3298	init_cgroup_housekeeping(cgrp);
3299
3300	cgrp->parent = parent;
3301	cgrp->root = parent->root;
3302	cgrp->top_cgroup = parent->top_cgroup;
3303
3304	if (notify_on_release(parent))
3305	set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
3306
3307	for_each_subsys(root, ss) {
3308	struct cgroup_subsys_state *css = ss->create(ss, cgrp);
3309
3310	if (IS_ERR(css)) {
3311	err = PTR_ERR(css);
3312	goto err_destroy;
3313	}
3314	init_cgroup_css(css, ss, cgrp);
3315	if (ss->use_id) {
3316	err = alloc_css_id(ss, parent, cgrp);
3317	if (err)
3318	goto err_destroy;
3319	}
3320	/* At error, ->destroy() callback has to free assigned ID. */
3321	}
3322
3323	cgroup_lock_hierarchy(root);
3324	list_add(&cgrp->sibling, &cgrp->parent->children);
3325	cgroup_unlock_hierarchy(root);
3326	root->number_of_cgroups++;
3327
3328	err = cgroup_create_dir(cgrp, dentry, mode);
3329	if (err < 0)
3330	goto err_remove;
3331
3332	/* The cgroup directory was pre-locked for us */
3333	BUG_ON(!mutex_is_locked(&cgrp->dentry->d_inode->i_mutex));
3334
3335	err = cgroup_populate_dir(cgrp);
3336	/* If err < 0, we have a half-filled directory - oh well ;) */
3337
3338	mutex_unlock(&cgroup_mutex);
3339	mutex_unlock(&cgrp->dentry->d_inode->i_mutex);
3340
3341	return 0;
3342
3343	err_remove:
3344
3345	cgroup_lock_hierarchy(root);
3346	list_del(&cgrp->sibling);
3347	cgroup_unlock_hierarchy(root);
3348	root->number_of_cgroups--;
3349
3350	err_destroy:
3351
3352	for_each_subsys(root, ss) {
3353	if (cgrp->subsys[ss->subsys_id])
3354	ss->destroy(ss, cgrp);
3355	}
3356
3357	mutex_unlock(&cgroup_mutex);
3358
3359	/* Release the reference count that we took on the superblock */
3360	deactivate_super(sb);
3361
3362	kfree(cgrp);
3363	return err;
3364	}
3365
3366	static int cgroup_mkdir(struct inode dir, struct dentry dentry, int mode)
3367	{
3368	struct cgroup *c_parent = dentry->d_parent->d_fsdata;
3369
3370	/* the vfs holds inode->i_mutex already */
3371	return cgroup_create(c_parent, dentry, mode \| S_IFDIR);
3372	}
3373
3374	static int cgroup_has_css_refs(struct cgroup *cgrp)
3375	{
3376	/* Check the reference count on each subsystem. Since we
3377	* already established that there are no tasks in the
3378	* cgroup, if the css refcount is also 1, then there should
3379	* be no outstanding references, so the subsystem is safe to
3380	* destroy. We scan across all subsystems rather than using
3381	* the per-hierarchy linked list of mounted subsystems since
3382	* we can be called via check_for_release() with no
3383	* synchronization other than RCU, and the subsystem linked
3384	* list isn't RCU-safe */
3385	int i;
3386	/*
3387	* We won't need to lock the subsys array, because the subsystems
3388	* we're concerned about aren't going anywhere since our cgroup root
3389	* has a reference on them.
3390	*/
3391	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
3392	struct cgroup_subsys *ss = subsys[i];
3393	struct cgroup_subsys_state *css;
3394	/* Skip subsystems not present or not in this hierarchy */
3395	if (ss == NULL \|\| ss->root != cgrp->root)
3396	continue;
3397	css = cgrp->subsys[ss->subsys_id];
3398	/* When called from check_for_release() it's possible
3399	* that by this point the cgroup has been removed
3400	* and the css deleted. But a false-positive doesn't
3401	* matter, since it can only happen if the cgroup
3402	* has been deleted and hence no longer needs the
3403	* release agent to be called anyway. */
3404	if (css && (atomic_read(&css->refcnt) > 1))
3405	return 1;
3406	}
3407	return 0;
3408	}
3409
3410	/*
3411	* Atomically mark all (or else none) of the cgroup's CSS objects as
3412	* CSS_REMOVED. Return true on success, or false if the cgroup has
3413	* busy subsystems. Call with cgroup_mutex held
3414	*/
3415
3416	static int cgroup_clear_css_refs(struct cgroup *cgrp)
3417	{
3418	struct cgroup_subsys *ss;
3419	unsigned long flags;
3420	bool failed = false;
3421	local_irq_save(flags);
3422	for_each_subsys(cgrp->root, ss) {
3423	struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
3424	int refcnt;
3425	while (1) {
3426	/* We can only remove a CSS with a refcnt==1 */
3427	refcnt = atomic_read(&css->refcnt);
3428	if (refcnt > 1) {
3429	failed = true;
3430	goto done;
3431	}
3432	BUG_ON(!refcnt);
3433	/*
3434	* Drop the refcnt to 0 while we check other
3435	* subsystems. This will cause any racing
3436	* css_tryget() to spin until we set the
3437	* CSS_REMOVED bits or abort
3438	*/
3439	if (atomic_cmpxchg(&css->refcnt, refcnt, 0) == refcnt)
3440	break;
3441	cpu_relax();
3442	}
3443	}
3444	done:
3445	for_each_subsys(cgrp->root, ss) {
3446	struct cgroup_subsys_state *css = cgrp->subsys[ss->subsys_id];
3447	if (failed) {
3448	/*
3449	* Restore old refcnt if we previously managed
3450	* to clear it from 1 to 0
3451	*/
3452	if (!atomic_read(&css->refcnt))
3453	atomic_set(&css->refcnt, 1);
3454	} else {
3455	/* Commit the fact that the CSS is removed */
3456	set_bit(CSS_REMOVED, &css->flags);
3457	}
3458	}
3459	local_irq_restore(flags);
3460	return !failed;
3461	}
3462
3463	static int cgroup_rmdir(struct inode unused_dir, struct dentry dentry)
3464	{
3465	struct cgroup *cgrp = dentry->d_fsdata;
3466	struct dentry *d;
3467	struct cgroup *parent;
3468	DEFINE_WAIT(wait);
3469	struct cgroup_event event, tmp;
3470	int ret;
3471
3472	/* the vfs holds both inode->i_mutex already */
3473	again:
3474	mutex_lock(&cgroup_mutex);
3475	if (atomic_read(&cgrp->count) != 0) {
3476	mutex_unlock(&cgroup_mutex);
3477	return -EBUSY;
3478	}
3479	if (!list_empty(&cgrp->children)) {
3480	mutex_unlock(&cgroup_mutex);
3481	return -EBUSY;
3482	}
3483	mutex_unlock(&cgroup_mutex);
3484
3485	/*
3486	* In general, subsystem has no css->refcnt after pre_destroy(). But
3487	* in racy cases, subsystem may have to get css->refcnt after
3488	* pre_destroy() and it makes rmdir return with -EBUSY. This sometimes
3489	* make rmdir return -EBUSY too often. To avoid that, we use waitqueue
3490	* for cgroup's rmdir. CGRP_WAIT_ON_RMDIR is for synchronizing rmdir
3491	* and subsystem's reference count handling. Please see css_get/put
3492	* and css_tryget() and cgroup_wakeup_rmdir_waiter() implementation.
3493	*/
3494	set_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
3495
3496	/*
3497	* Call pre_destroy handlers of subsys. Notify subsystems
3498	* that rmdir() request comes.
3499	*/
3500	ret = cgroup_call_pre_destroy(cgrp);
3501	if (ret) {
3502	clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
3503	return ret;
3504	}
3505
3506	mutex_lock(&cgroup_mutex);
3507	parent = cgrp->parent;
3508	if (atomic_read(&cgrp->count) \|\| !list_empty(&cgrp->children)) {
3509	clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
3510	mutex_unlock(&cgroup_mutex);
3511	return -EBUSY;
3512	}
3513	prepare_to_wait(&cgroup_rmdir_waitq, &wait, TASK_INTERRUPTIBLE);
3514	if (!cgroup_clear_css_refs(cgrp)) {
3515	mutex_unlock(&cgroup_mutex);
3516	/*
3517	* Because someone may call cgroup_wakeup_rmdir_waiter() before
3518	* prepare_to_wait(), we need to check this flag.
3519	*/
3520	if (test_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags))
3521	schedule();
3522	finish_wait(&cgroup_rmdir_waitq, &wait);
3523	clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
3524	if (signal_pending(current))
3525	return -EINTR;
3526	goto again;
3527	}
3528	/* NO css_tryget() can success after here. */
3529	finish_wait(&cgroup_rmdir_waitq, &wait);
3530	clear_bit(CGRP_WAIT_ON_RMDIR, &cgrp->flags);
3531
3532	spin_lock(&release_list_lock);
3533	set_bit(CGRP_REMOVED, &cgrp->flags);
3534	if (!list_empty(&cgrp->release_list))
3535	list_del(&cgrp->release_list);
3536	spin_unlock(&release_list_lock);
3537
3538	cgroup_lock_hierarchy(cgrp->root);
3539	/* delete this cgroup from parent->children */
3540	list_del(&cgrp->sibling);
3541	cgroup_unlock_hierarchy(cgrp->root);
3542
3543	spin_lock(&cgrp->dentry->d_lock);
3544	d = dget(cgrp->dentry);
3545	spin_unlock(&d->d_lock);
3546
3547	cgroup_d_remove_dir(d);
3548	dput(d);
3549
3550	set_bit(CGRP_RELEASABLE, &parent->flags);
3551	check_for_release(parent);
3552
3553	/*
3554	* Unregister events and notify userspace.
3555	* Notify userspace about cgroup removing only after rmdir of cgroup
3556	* directory to avoid race between userspace and kernelspace
3557	*/
3558	spin_lock(&cgrp->event_list_lock);
3559	list_for_each_entry_safe(event, tmp, &cgrp->event_list, list) {
3560	list_del(&event->list);
3561	remove_wait_queue(event->wqh, &event->wait);
3562	eventfd_signal(event->eventfd, 1);
3563	schedule_work(&event->remove);
3564	}
3565	spin_unlock(&cgrp->event_list_lock);
3566
3567	mutex_unlock(&cgroup_mutex);
3568	return 0;
3569	}
3570
3571	static void __init cgroup_init_subsys(struct cgroup_subsys *ss)
3572	{
3573	struct cgroup_subsys_state *css;
3574
3575	printk(KERN_INFO "Initializing cgroup subsys %s\n", ss->name);
3576
3577	/* Create the top cgroup state for this subsystem */
3578	list_add(&ss->sibling, &rootnode.subsys_list);
3579	ss->root = &rootnode;
3580	css = ss->create(ss, dummytop);
3581	/* We don't handle early failures gracefully */
3582	BUG_ON(IS_ERR(css));
3583	init_cgroup_css(css, ss, dummytop);
3584
3585	/* Update the init_css_set to contain a subsys
3586	* pointer to this state - since the subsystem is
3587	* newly registered, all tasks and hence the
3588	* init_css_set is in the subsystem's top cgroup. */
3589	init_css_set.subsys[ss->subsys_id] = dummytop->subsys[ss->subsys_id];
3590
3591	need_forkexit_callback \|= ss->fork \|\| ss->exit;
3592
3593	/* At system boot, before all subsystems have been
3594	* registered, no tasks have been forked, so we don't
3595	* need to invoke fork callbacks here. */
3596	BUG_ON(!list_empty(&init_task.tasks));
3597
3598	mutex_init(&ss->hierarchy_mutex);
3599	lockdep_set_class(&ss->hierarchy_mutex, &ss->subsys_key);
3600	ss->active = 1;
3601
3602	/* this function shouldn't be used with modular subsystems, since they
3603	* need to register a subsys_id, among other things */
3604	BUG_ON(ss->module);
3605	}
3606
3607	/**
3608	* cgroup_load_subsys: load and register a modular subsystem at runtime
3609	* @ss: the subsystem to load
3610	*
3611	* This function should be called in a modular subsystem's initcall. If the
3612	* subsytem is built as a module, it will be assigned a new subsys_id and set
3613	* up for use. If the subsystem is built-in anyway, work is delegated to the
3614	* simpler cgroup_init_subsys.
3615	*/
3616	int __init_or_module cgroup_load_subsys(struct cgroup_subsys *ss)
3617	{
3618	int i;
3619	struct cgroup_subsys_state *css;
3620
3621	/* check name and function validity */
3622	if (ss->name == NULL \|\| strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN \|\|
3623	ss->create == NULL \|\| ss->destroy == NULL)
3624	return -EINVAL;
3625
3626	/*
3627	* we don't support callbacks in modular subsystems. this check is
3628	* before the ss->module check for consistency; a subsystem that could
3629	* be a module should still have no callbacks even if the user isn't
3630	* compiling it as one.
3631	*/
3632	if (ss->fork \|\| ss->exit)
3633	return -EINVAL;
3634
3635	/*
3636	* an optionally modular subsystem is built-in: we want to do nothing,
3637	* since cgroup_init_subsys will have already taken care of it.
3638	*/
3639	if (ss->module == NULL) {
3640	/* a few sanity checks */
3641	BUG_ON(ss->subsys_id >= CGROUP_BUILTIN_SUBSYS_COUNT);
3642	BUG_ON(subsys[ss->subsys_id] != ss);
3643	return 0;
3644	}
3645
3646	/*
3647	* need to register a subsys id before anything else - for example,
3648	* init_cgroup_css needs it.
3649	*/
3650	mutex_lock(&cgroup_mutex);
3651	/* find the first empty slot in the array */
3652	for (i = CGROUP_BUILTIN_SUBSYS_COUNT; i < CGROUP_SUBSYS_COUNT; i++) {
3653	if (subsys[i] == NULL)
3654	break;
3655	}
3656	if (i == CGROUP_SUBSYS_COUNT) {
3657	/* maximum number of subsystems already registered! */
3658	mutex_unlock(&cgroup_mutex);
3659	return -EBUSY;
3660	}
3661	/* assign ourselves the subsys_id */
3662	ss->subsys_id = i;
3663	subsys[i] = ss;
3664
3665	/*
3666	* no ss->create seems to need anything important in the ss struct, so
3667	* this can happen first (i.e. before the rootnode attachment).
3668	*/
3669	css = ss->create(ss, dummytop);
3670	if (IS_ERR(css)) {
3671	/* failure case - need to deassign the subsys[] slot. */
3672	subsys[i] = NULL;
3673	mutex_unlock(&cgroup_mutex);
3674	return PTR_ERR(css);
3675	}
3676
3677	list_add(&ss->sibling, &rootnode.subsys_list);
3678	ss->root = &rootnode;
3679
3680	/* our new subsystem will be attached to the dummy hierarchy. */
3681	init_cgroup_css(css, ss, dummytop);
3682	/* init_idr must be after init_cgroup_css because it sets css->id. */
3683	if (ss->use_id) {
3684	int ret = cgroup_init_idr(ss, css);
3685	if (ret) {
3686	dummytop->subsys[ss->subsys_id] = NULL;
3687	ss->destroy(ss, dummytop);
3688	subsys[i] = NULL;
3689	mutex_unlock(&cgroup_mutex);
3690	return ret;
3691	}
3692	}
3693
3694	/*
3695	* Now we need to entangle the css into the existing css_sets. unlike
3696	* in cgroup_init_subsys, there are now multiple css_sets, so each one
3697	* will need a new pointer to it; done by iterating the css_set_table.
3698	* furthermore, modifying the existing css_sets will corrupt the hash
3699	* table state, so each changed css_set will need its hash recomputed.
3700	* this is all done under the css_set_lock.
3701	*/
3702	write_lock(&css_set_lock);
3703	for (i = 0; i < CSS_SET_TABLE_SIZE; i++) {
3704	struct css_set *cg;
3705	struct hlist_node node, tmp;
3706	struct hlist_head bucket = &css_set_table[i], new_bucket;
3707
3708	hlist_for_each_entry_safe(cg, node, tmp, bucket, hlist) {
3709	/* skip entries that we already rehashed */
3710	if (cg->subsys[ss->subsys_id])
3711	continue;
3712	/* remove existing entry */
3713	hlist_del(&cg->hlist);
3714	/* set new value */
3715	cg->subsys[ss->subsys_id] = css;
3716	/* recompute hash and restore entry */
3717	new_bucket = css_set_hash(cg->subsys);
3718	hlist_add_head(&cg->hlist, new_bucket);
3719	}
3720	}
3721	write_unlock(&css_set_lock);
3722
3723	mutex_init(&ss->hierarchy_mutex);
3724	lockdep_set_class(&ss->hierarchy_mutex, &ss->subsys_key);
3725	ss->active = 1;
3726
3727	/* success! */
3728	mutex_unlock(&cgroup_mutex);
3729	return 0;
3730	}
3731	EXPORT_SYMBOL_GPL(cgroup_load_subsys);
3732
3733	/**
3734	* cgroup_unload_subsys: unload a modular subsystem
3735	* @ss: the subsystem to unload
3736	*
3737	* This function should be called in a modular subsystem's exitcall. When this
3738	* function is invoked, the refcount on the subsystem's module will be 0, so
3739	* the subsystem will not be attached to any hierarchy.
3740	*/
3741	void cgroup_unload_subsys(struct cgroup_subsys *ss)
3742	{
3743	struct cg_cgroup_link *link;
3744	struct hlist_head *hhead;
3745
3746	BUG_ON(ss->module == NULL);
3747
3748	/*
3749	* we shouldn't be called if the subsystem is in use, and the use of
3750	* try_module_get in parse_cgroupfs_options should ensure that it
3751	* doesn't start being used while we're killing it off.
3752	*/
3753	BUG_ON(ss->root != &rootnode);
3754
3755	mutex_lock(&cgroup_mutex);
3756	/* deassign the subsys_id */
3757	BUG_ON(ss->subsys_id < CGROUP_BUILTIN_SUBSYS_COUNT);
3758	subsys[ss->subsys_id] = NULL;
3759
3760	/* remove subsystem from rootnode's list of subsystems */
3761	list_del(&ss->sibling);
3762
3763	/*
3764	* disentangle the css from all css_sets attached to the dummytop. as
3765	* in loading, we need to pay our respects to the hashtable gods.
3766	*/
3767	write_lock(&css_set_lock);
3768	list_for_each_entry(link, &dummytop->css_sets, cgrp_link_list) {
3769	struct css_set *cg = link->cg;
3770
3771	hlist_del(&cg->hlist);
3772	BUG_ON(!cg->subsys[ss->subsys_id]);
3773	cg->subsys[ss->subsys_id] = NULL;
3774	hhead = css_set_hash(cg->subsys);
3775	hlist_add_head(&cg->hlist, hhead);
3776	}
3777	write_unlock(&css_set_lock);
3778
3779	/*
3780	* remove subsystem's css from the dummytop and free it - need to free
3781	* before marking as null because ss->destroy needs the cgrp->subsys
3782	* pointer to find their state. note that this also takes care of
3783	* freeing the css_id.
3784	*/
3785	ss->destroy(ss, dummytop);
3786	dummytop->subsys[ss->subsys_id] = NULL;
3787
3788	mutex_unlock(&cgroup_mutex);
3789	}
3790	EXPORT_SYMBOL_GPL(cgroup_unload_subsys);
3791
3792	/**
3793	* cgroup_init_early - cgroup initialization at system boot
3794	*
3795	* Initialize cgroups at system boot, and initialize any
3796	* subsystems that request early init.
3797	*/
3798	int __init cgroup_init_early(void)
3799	{
3800	int i;
3801	atomic_set(&init_css_set.refcount, 1);
3802	INIT_LIST_HEAD(&init_css_set.cg_links);
3803	INIT_LIST_HEAD(&init_css_set.tasks);
3804	INIT_HLIST_NODE(&init_css_set.hlist);
3805	css_set_count = 1;
3806	init_cgroup_root(&rootnode);
3807	root_count = 1;
3808	init_task.cgroups = &init_css_set;
3809
3810	init_css_set_link.cg = &init_css_set;
3811	init_css_set_link.cgrp = dummytop;
3812	list_add(&init_css_set_link.cgrp_link_list,
3813	&rootnode.top_cgroup.css_sets);
3814	list_add(&init_css_set_link.cg_link_list,
3815	&init_css_set.cg_links);
3816
3817	for (i = 0; i < CSS_SET_TABLE_SIZE; i++)
3818	INIT_HLIST_HEAD(&css_set_table[i]);
3819
3820	/* at bootup time, we don't worry about modular subsystems */
3821	for (i = 0; i < CGROUP_BUILTIN_SUBSYS_COUNT; i++) {
3822	struct cgroup_subsys *ss = subsys[i];
3823
3824	BUG_ON(!ss->name);
3825	BUG_ON(strlen(ss->name) > MAX_CGROUP_TYPE_NAMELEN);
3826	BUG_ON(!ss->create);
3827	BUG_ON(!ss->destroy);
3828	if (ss->subsys_id != i) {
3829	printk(KERN_ERR "cgroup: Subsys %s id == %d\n",
3830	ss->name, ss->subsys_id);
3831	BUG();
3832	}
3833
3834	if (ss->early_init)
3835	cgroup_init_subsys(ss);
3836	}
3837	return 0;
3838	}
3839
3840	/**
3841	* cgroup_init - cgroup initialization
3842	*
3843	* Register cgroup filesystem and /proc file, and initialize
3844	* any subsystems that didn't request early init.
3845	*/
3846	int __init cgroup_init(void)
3847	{
3848	int err;
3849	int i;
3850	struct hlist_head *hhead;
3851
3852	err = bdi_init(&cgroup_backing_dev_info);
3853	if (err)
3854	return err;
3855
3856	/* at bootup time, we don't worry about modular subsystems */
3857	for (i = 0; i < CGROUP_BUILTIN_SUBSYS_COUNT; i++) {
3858	struct cgroup_subsys *ss = subsys[i];
3859	if (!ss->early_init)
3860	cgroup_init_subsys(ss);
3861	if (ss->use_id)
3862	cgroup_init_idr(ss, init_css_set.subsys[ss->subsys_id]);
3863	}
3864
3865	/* Add init_css_set to the hash table */
3866	hhead = css_set_hash(init_css_set.subsys);
3867	hlist_add_head(&init_css_set.hlist, hhead);
3868	BUG_ON(!init_root_id(&rootnode));
3869	err = register_filesystem(&cgroup_fs_type);
3870	if (err < 0)
3871	goto out;
3872
3873	proc_create("cgroups", 0, NULL, &proc_cgroupstats_operations);
3874
3875	out:
3876	if (err)
3877	bdi_destroy(&cgroup_backing_dev_info);
3878
3879	return err;
3880	}
3881
3882	/*
3883	* proc_cgroup_show()
3884	* - Print task's cgroup paths into seq_file, one line for each hierarchy
3885	* - Used for /proc/<pid>/cgroup.
3886	* - No need to task_lock(tsk) on this tsk->cgroup reference, as it
3887	* doesn't really matter if tsk->cgroup changes after we read it,
3888	* and we take cgroup_mutex, keeping cgroup_attach_task() from changing it
3889	* anyway. No need to check that tsk->cgroup != NULL, thanks to
3890	* the_top_cgroup_hack in cgroup_exit(), which sets an exiting tasks
3891	* cgroup to top_cgroup.
3892	*/
3893
3894	/* TODO: Use a proper seq_file iterator */
3895	static int proc_cgroup_show(struct seq_file m, void v)
3896	{
3897	struct pid *pid;
3898	struct task_struct *tsk;
3899	char *buf;
3900	int retval;
3901	struct cgroupfs_root *root;
3902
3903	retval = -ENOMEM;
3904	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
3905	if (!buf)
3906	goto out;
3907
3908	retval = -ESRCH;
3909	pid = m->private;
3910	tsk = get_pid_task(pid, PIDTYPE_PID);
3911	if (!tsk)
3912	goto out_free;
3913
3914	retval = 0;
3915
3916	mutex_lock(&cgroup_mutex);
3917
3918	for_each_active_root(root) {
3919	struct cgroup_subsys *ss;
3920	struct cgroup *cgrp;
3921	int count = 0;
3922
3923	seq_printf(m, "%d:", root->hierarchy_id);
3924	for_each_subsys(root, ss)
3925	seq_printf(m, "%s%s", count++ ? "," : "", ss->name);
3926	if (strlen(root->name))
3927	seq_printf(m, "%sname=%s", count ? "," : "",
3928	root->name);
3929	seq_putc(m, ':');
3930	cgrp = task_cgroup_from_root(tsk, root);
3931	retval = cgroup_path(cgrp, buf, PAGE_SIZE);
3932	if (retval < 0)
3933	goto out_unlock;
3934	seq_puts(m, buf);
3935	seq_putc(m, '\n');
3936	}
3937
3938	out_unlock:
3939	mutex_unlock(&cgroup_mutex);
3940	put_task_struct(tsk);
3941	out_free:
3942	kfree(buf);
3943	out:
3944	return retval;
3945	}
3946
3947	static int cgroup_open(struct inode inode, struct file file)
3948	{
3949	struct pid *pid = PROC_I(inode)->pid;
3950	return single_open(file, proc_cgroup_show, pid);
3951	}
3952
3953	const struct file_operations proc_cgroup_operations = {
3954	.open = cgroup_open,
3955	.read = seq_read,
3956	.llseek = seq_lseek,
3957	.release = single_release,
3958	};
3959
3960	/* Display information about each subsystem and each hierarchy */
3961	static int proc_cgroupstats_show(struct seq_file m, void v)
3962	{
3963	int i;
3964
3965	seq_puts(m, "#subsys_name\thierarchy\tnum_cgroups\tenabled\n");
3966	/*
3967	* ideally we don't want subsystems moving around while we do this.
3968	* cgroup_mutex is also necessary to guarantee an atomic snapshot of
3969	* subsys/hierarchy state.
3970	*/
3971	mutex_lock(&cgroup_mutex);
3972	for (i = 0; i < CGROUP_SUBSYS_COUNT; i++) {
3973	struct cgroup_subsys *ss = subsys[i];
3974	if (ss == NULL)
3975	continue;
3976	seq_printf(m, "%s\t%d\t%d\t%d\n",
3977	ss->name, ss->root->hierarchy_id,
3978	ss->root->number_of_cgroups, !ss->disabled);
3979	}
3980	mutex_unlock(&cgroup_mutex);
3981	return 0;
3982	}
3983
3984	static int cgroupstats_open(struct inode inode, struct file file)
3985	{
3986	return single_open(file, proc_cgroupstats_show, NULL);
3987	}
3988
3989	static const struct file_operations proc_cgroupstats_operations = {
3990	.open = cgroupstats_open,
3991	.read = seq_read,
3992	.llseek = seq_lseek,
3993	.release = single_release,
3994	};
3995
3996	/**
3997	* cgroup_fork - attach newly forked task to its parents cgroup.
3998	* @child: pointer to task_struct of forking parent process.
3999	*
4000	* Description: A task inherits its parent's cgroup at fork().
4001	*
4002	* A pointer to the shared css_set was automatically copied in
4003	* fork.c by dup_task_struct(). However, we ignore that copy, since
4004	* it was not made under the protection of RCU or cgroup_mutex, so
4005	* might no longer be a valid cgroup pointer. cgroup_attach_task() might
4006	* have already changed current->cgroups, allowing the previously
4007	* referenced cgroup group to be removed and freed.
4008	*
4009	* At the point that cgroup_fork() is called, 'current' is the parent
4010	* task, and the passed argument 'child' points to the child task.
4011	*/
4012	void cgroup_fork(struct task_struct *child)
4013	{
4014	task_lock(current);
4015	child->cgroups = current->cgroups;
4016	get_css_set(child->cgroups);
4017	task_unlock(current);
4018	INIT_LIST_HEAD(&child->cg_list);
4019	}
4020
4021	/**
4022	* cgroup_fork_callbacks - run fork callbacks
4023	* @child: the new task
4024	*
4025	* Called on a new task very soon before adding it to the
4026	* tasklist. No need to take any locks since no-one can
4027	* be operating on this task.
4028	*/
4029	void cgroup_fork_callbacks(struct task_struct *child)
4030	{
4031	if (need_forkexit_callback) {
4032	int i;
4033	/*
4034	* forkexit callbacks are only supported for builtin
4035	* subsystems, and the builtin section of the subsys array is
4036	* immutable, so we don't need to lock the subsys array here.
4037	*/
4038	for (i = 0; i < CGROUP_BUILTIN_SUBSYS_COUNT; i++) {
4039	struct cgroup_subsys *ss = subsys[i];
4040	if (ss->fork)
4041	ss->fork(ss, child);
4042	}
4043	}
4044	}
4045
4046	/**
4047	* cgroup_post_fork - called on a new task after adding it to the task list
4048	* @child: the task in question
4049	*
4050	* Adds the task to the list running through its css_set if necessary.
4051	* Has to be after the task is visible on the task list in case we race
4052	* with the first call to cgroup_iter_start() - to guarantee that the
4053	* new task ends up on its list.
4054	*/
4055	void cgroup_post_fork(struct task_struct *child)
4056	{
4057	if (use_task_css_set_links) {
4058	write_lock(&css_set_lock);
4059	task_lock(child);
4060	if (list_empty(&child->cg_list))
4061	list_add(&child->cg_list, &child->cgroups->tasks);
4062	task_unlock(child);
4063	write_unlock(&css_set_lock);
4064	}
4065	}
4066	/**
4067	* cgroup_exit - detach cgroup from exiting task
4068	* @tsk: pointer to task_struct of exiting process
4069	* @run_callback: run exit callbacks?
4070	*
4071	* Description: Detach cgroup from @tsk and release it.
4072	*
4073	* Note that cgroups marked notify_on_release force every task in
4074	* them to take the global cgroup_mutex mutex when exiting.
4075	* This could impact scaling on very large systems. Be reluctant to
4076	* use notify_on_release cgroups where very high task exit scaling
4077	* is required on large systems.
4078	*
4079	* the_top_cgroup_hack:
4080	*
4081	* Set the exiting tasks cgroup to the root cgroup (top_cgroup).
4082	*
4083	* We call cgroup_exit() while the task is still competent to
4084	* handle notify_on_release(), then leave the task attached to the
4085	* root cgroup in each hierarchy for the remainder of its exit.
4086	*
4087	* To do this properly, we would increment the reference count on
4088	* top_cgroup, and near the very end of the kernel/exit.c do_exit()
4089	* code we would add a second cgroup function call, to drop that
4090	* reference. This would just create an unnecessary hot spot on
4091	* the top_cgroup reference count, to no avail.
4092	*
4093	* Normally, holding a reference to a cgroup without bumping its
4094	* count is unsafe. The cgroup could go away, or someone could
4095	* attach us to a different cgroup, decrementing the count on
4096	* the first cgroup that we never incremented. But in this case,
4097	* top_cgroup isn't going away, and either task has PF_EXITING set,
4098	* which wards off any cgroup_attach_task() attempts, or task is a failed
4099	* fork, never visible to cgroup_attach_task.
4100	*/
4101	void cgroup_exit(struct task_struct *tsk, int run_callbacks)
4102	{
4103	int i;
4104	struct css_set *cg;
4105
4106	if (run_callbacks && need_forkexit_callback) {
4107	/*
4108	* modular subsystems can't use callbacks, so no need to lock
4109	* the subsys array
4110	*/
4111	for (i = 0; i < CGROUP_BUILTIN_SUBSYS_COUNT; i++) {
4112	struct cgroup_subsys *ss = subsys[i];
4113	if (ss->exit)
4114	ss->exit(ss, tsk);
4115	}
4116	}
4117
4118	/*
4119	* Unlink from the css_set task list if necessary.
4120	* Optimistically check cg_list before taking
4121	* css_set_lock
4122	*/
4123	if (!list_empty(&tsk->cg_list)) {
4124	write_lock(&css_set_lock);
4125	if (!list_empty(&tsk->cg_list))
4126	list_del(&tsk->cg_list);
4127	write_unlock(&css_set_lock);
4128	}
4129
4130	/* Reassign the task to the init_css_set. */
4131	task_lock(tsk);
4132	cg = tsk->cgroups;
4133	tsk->cgroups = &init_css_set;
4134	task_unlock(tsk);
4135	if (cg)
4136	put_css_set_taskexit(cg);
4137	}
4138
4139	/**
4140	* cgroup_clone - clone the cgroup the given subsystem is attached to
4141	* @tsk: the task to be moved
4142	* @subsys: the given subsystem
4143	* @nodename: the name for the new cgroup
4144	*
4145	* Duplicate the current cgroup in the hierarchy that the given
4146	* subsystem is attached to, and move this task into the new
4147	* child.
4148	*/
4149	int cgroup_clone(struct task_struct tsk, struct cgroup_subsys subsys,
4150	char *nodename)
4151	{
4152	struct dentry *dentry;
4153	int ret = 0;
4154	struct cgroup parent, child;
4155	struct inode *inode;
4156	struct css_set *cg;
4157	struct cgroupfs_root *root;
4158	struct cgroup_subsys *ss;
4159
4160	/* We shouldn't be called by an unregistered subsystem */
4161	BUG_ON(!subsys->active);
4162
4163	/* First figure out what hierarchy and cgroup we're dealing
4164	* with, and pin them so we can drop cgroup_mutex */
4165	mutex_lock(&cgroup_mutex);
4166	again:
4167	root = subsys->root;
4168	if (root == &rootnode) {
4169	mutex_unlock(&cgroup_mutex);
4170	return 0;
4171	}
4172
4173	/* Pin the hierarchy */
4174	if (!atomic_inc_not_zero(&root->sb->s_active)) {
4175	/* We race with the final deactivate_super() */
4176	mutex_unlock(&cgroup_mutex);
4177	return 0;
4178	}
4179
4180	/* Keep the cgroup alive */
4181	task_lock(tsk);
4182	parent = task_cgroup(tsk, subsys->subsys_id);
4183	cg = tsk->cgroups;
4184	get_css_set(cg);
4185	task_unlock(tsk);
4186
4187	mutex_unlock(&cgroup_mutex);
4188
4189	/* Now do the VFS work to create a cgroup */
4190	inode = parent->dentry->d_inode;
4191
4192	/* Hold the parent directory mutex across this operation to
4193	* stop anyone else deleting the new cgroup */
4194	mutex_lock(&inode->i_mutex);
4195	dentry = lookup_one_len(nodename, parent->dentry, strlen(nodename));
4196	if (IS_ERR(dentry)) {
4197	printk(KERN_INFO
4198	"cgroup: Couldn't allocate dentry for %s: %ld\n", nodename,
4199	PTR_ERR(dentry));
4200	ret = PTR_ERR(dentry);
4201	goto out_release;
4202	}
4203
4204	/* Create the cgroup directory, which also creates the cgroup */
4205	ret = vfs_mkdir(inode, dentry, 0755);
4206	child = __d_cgrp(dentry);
4207	dput(dentry);
4208	if (ret) {
4209	printk(KERN_INFO
4210	"Failed to create cgroup %s: %d\n", nodename,
4211	ret);
4212	goto out_release;
4213	}
4214
4215	/* The cgroup now exists. Retake cgroup_mutex and check
4216	* that we're still in the same state that we thought we
4217	* were. */
4218	mutex_lock(&cgroup_mutex);
4219	if ((root != subsys->root) \|\|
4220	(parent != task_cgroup(tsk, subsys->subsys_id))) {
4221	/* Aargh, we raced ... */
4222	mutex_unlock(&inode->i_mutex);
4223	put_css_set(cg);
4224
4225	deactivate_super(root->sb);
4226	/* The cgroup is still accessible in the VFS, but
4227	* we're not going to try to rmdir() it at this
4228	* point. */
4229	printk(KERN_INFO
4230	"Race in cgroup_clone() - leaking cgroup %s\n",
4231	nodename);
4232	goto again;
4233	}
4234
4235	/* do any required auto-setup */
4236	for_each_subsys(root, ss) {
4237	if (ss->post_clone)
4238	ss->post_clone(ss, child);
4239	}
4240
4241	/* All seems fine. Finish by moving the task into the new cgroup */
4242	ret = cgroup_attach_task(child, tsk);
4243	mutex_unlock(&cgroup_mutex);
4244
4245	out_release:
4246	mutex_unlock(&inode->i_mutex);
4247
4248	mutex_lock(&cgroup_mutex);
4249	put_css_set(cg);
4250	mutex_unlock(&cgroup_mutex);
4251	deactivate_super(root->sb);
4252	return ret;
4253	}
4254
4255	/**
4256	* cgroup_is_descendant - see if @cgrp is a descendant of @task's cgrp
4257	* @cgrp: the cgroup in question
4258	* @task: the task in question
4259	*
4260	* See if @cgrp is a descendant of @task's cgroup in the appropriate
4261	* hierarchy.
4262	*
4263	* If we are sending in dummytop, then presumably we are creating
4264	* the top cgroup in the subsystem.
4265	*
4266	* Called only by the ns (nsproxy) cgroup.
4267	*/
4268	int cgroup_is_descendant(const struct cgroup cgrp, struct task_struct task)
4269	{
4270	int ret;
4271	struct cgroup *target;
4272
4273	if (cgrp == dummytop)
4274	return 1;
4275
4276	target = task_cgroup_from_root(task, cgrp->root);
4277	while (cgrp != target && cgrp!= cgrp->top_cgroup)
4278	cgrp = cgrp->parent;
4279	ret = (cgrp == target);
4280	return ret;
4281	}
4282
4283	static void check_for_release(struct cgroup *cgrp)
4284	{
4285	/* All of these checks rely on RCU to keep the cgroup
4286	* structure alive */
4287	if (cgroup_is_releasable(cgrp) && !atomic_read(&cgrp->count)
4288	&& list_empty(&cgrp->children) && !cgroup_has_css_refs(cgrp)) {
4289	/* Control Group is currently removeable. If it's not
4290	* already queued for a userspace notification, queue
4291	* it now */
4292	int need_schedule_work = 0;
4293	spin_lock(&release_list_lock);
4294	if (!cgroup_is_removed(cgrp) &&
4295	list_empty(&cgrp->release_list)) {
4296	list_add(&cgrp->release_list, &release_list);
4297	need_schedule_work = 1;
4298	}
4299	spin_unlock(&release_list_lock);
4300	if (need_schedule_work)
4301	schedule_work(&release_agent_work);
4302	}
4303	}
4304
4305	/* Caller must verify that the css is not for root cgroup */
4306	void __css_put(struct cgroup_subsys_state *css, int count)
4307	{
4308	struct cgroup *cgrp = css->cgroup;
4309	int val;
4310	rcu_read_lock();
4311	val = atomic_sub_return(count, &css->refcnt);
4312	if (val == 1) {
4313	if (notify_on_release(cgrp)) {
4314	set_bit(CGRP_RELEASABLE, &cgrp->flags);
4315	check_for_release(cgrp);
4316	}
4317	cgroup_wakeup_rmdir_waiter(cgrp);
4318	}
4319	rcu_read_unlock();
4320	WARN_ON_ONCE(val < 1);
4321	}
4322	EXPORT_SYMBOL_GPL(__css_put);
4323
4324	/*
4325	* Notify userspace when a cgroup is released, by running the
4326	* configured release agent with the name of the cgroup (path
4327	* relative to the root of cgroup file system) as the argument.
4328	*
4329	* Most likely, this user command will try to rmdir this cgroup.
4330	*
4331	* This races with the possibility that some other task will be
4332	* attached to this cgroup before it is removed, or that some other
4333	* user task will 'mkdir' a child cgroup of this cgroup. That's ok.
4334	* The presumed 'rmdir' will fail quietly if this cgroup is no longer
4335	* unused, and this cgroup will be reprieved from its death sentence,
4336	* to continue to serve a useful existence. Next time it's released,
4337	* we will get notified again, if it still has 'notify_on_release' set.
4338	*
4339	* The final arg to call_usermodehelper() is UMH_WAIT_EXEC, which
4340	* means only wait until the task is successfully execve()'d. The
4341	* separate release agent task is forked by call_usermodehelper(),
4342	* then control in this thread returns here, without waiting for the
4343	* release agent task. We don't bother to wait because the caller of
4344	* this routine has no use for the exit status of the release agent
4345	* task, so no sense holding our caller up for that.
4346	*/
4347	static void cgroup_release_agent(struct work_struct *work)
4348	{
4349	BUG_ON(work != &release_agent_work);
4350	mutex_lock(&cgroup_mutex);
4351	spin_lock(&release_list_lock);
4352	while (!list_empty(&release_list)) {
4353	char argv[3], envp[3];
4354	int i;
4355	char pathbuf = NULL, agentbuf = NULL;
4356	struct cgroup *cgrp = list_entry(release_list.next,
4357	struct cgroup,
4358	release_list);
4359	list_del_init(&cgrp->release_list);
4360	spin_unlock(&release_list_lock);
4361	pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
4362	if (!pathbuf)
4363	goto continue_free;
4364	if (cgroup_path(cgrp, pathbuf, PAGE_SIZE) < 0)
4365	goto continue_free;
4366	agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL);
4367	if (!agentbuf)
4368	goto continue_free;
4369
4370	i = 0;
4371	argv[i++] = agentbuf;
4372	argv[i++] = pathbuf;
4373	argv[i] = NULL;
4374
4375	i = 0;
4376	/* minimal command environment */
4377	envp[i++] = "HOME=/";
4378	envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
4379	envp[i] = NULL;
4380
4381	/* Drop the lock while we invoke the usermode helper,
4382	* since the exec could involve hitting disk and hence
4383	* be a slow process */
4384	mutex_unlock(&cgroup_mutex);
4385	call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
4386	mutex_lock(&cgroup_mutex);
4387	continue_free:
4388	kfree(pathbuf);
4389	kfree(agentbuf);
4390	spin_lock(&release_list_lock);
4391	}
4392	spin_unlock(&release_list_lock);
4393	mutex_unlock(&cgroup_mutex);
4394	}
4395
4396	static int __init cgroup_disable(char *str)
4397	{
4398	int i;
4399	char *token;
4400
4401	while ((token = strsep(&str, ",")) != NULL) {
4402	if (!*token)
4403	continue;
4404	/*
4405	* cgroup_disable, being at boot time, can't know about module
4406	* subsystems, so we don't worry about them.
4407	*/
4408	for (i = 0; i < CGROUP_BUILTIN_SUBSYS_COUNT; i++) {
4409	struct cgroup_subsys *ss = subsys[i];
4410
4411	if (!strcmp(token, ss->name)) {
4412	ss->disabled = 1;
4413	printk(KERN_INFO "Disabling %s control group"
4414	" subsystem\n", ss->name);
4415	break;
4416	}
4417	}
4418	}
4419	return 1;
4420	}
4421	__setup("cgroup_disable=", cgroup_disable);
4422
4423	/*
4424	* Functons for CSS ID.
4425	*/
4426
4427	/*
4428	*To get ID other than 0, this should be called when !cgroup_is_removed().
4429	*/
4430	unsigned short css_id(struct cgroup_subsys_state *css)
4431	{
4432	struct css_id *cssid = rcu_dereference(css->id);
4433
4434	if (cssid)
4435	return cssid->id;
4436	return 0;
4437	}
4438	EXPORT_SYMBOL_GPL(css_id);
4439
4440	unsigned short css_depth(struct cgroup_subsys_state *css)
4441	{
4442	struct css_id *cssid = rcu_dereference(css->id);
4443
4444	if (cssid)
4445	return cssid->depth;
4446	return 0;
4447	}
4448	EXPORT_SYMBOL_GPL(css_depth);
4449
4450	bool css_is_ancestor(struct cgroup_subsys_state *child,
4451	const struct cgroup_subsys_state *root)
4452	{
4453	struct css_id *child_id = rcu_dereference(child->id);
4454	struct css_id *root_id = rcu_dereference(root->id);
4455
4456	if (!child_id \|\| !root_id \|\| (child_id->depth < root_id->depth))
4457	return false;
4458	return child_id->stack[root_id->depth] == root_id->id;
4459	}
4460
4461	static void __free_css_id_cb(struct rcu_head *head)
4462	{
4463	struct css_id *id;
4464
4465	id = container_of(head, struct css_id, rcu_head);
4466	kfree(id);
4467	}
4468
4469	void free_css_id(struct cgroup_subsys ss, struct cgroup_subsys_state css)
4470	{
4471	struct css_id *id = css->id;
4472	/* When this is called before css_id initialization, id can be NULL */
4473	if (!id)
4474	return;
4475
4476	BUG_ON(!ss->use_id);
4477
4478	rcu_assign_pointer(id->css, NULL);
4479	rcu_assign_pointer(css->id, NULL);
4480	spin_lock(&ss->id_lock);
4481	idr_remove(&ss->idr, id->id);
4482	spin_unlock(&ss->id_lock);
4483	call_rcu(&id->rcu_head, __free_css_id_cb);
4484	}
4485	EXPORT_SYMBOL_GPL(free_css_id);
4486
4487	/*
4488	* This is called by init or create(). Then, calls to this function are
4489	* always serialized (By cgroup_mutex() at create()).
4490	*/
4491
4492	static struct css_id get_new_cssid(struct cgroup_subsys ss, int depth)
4493	{
4494	struct css_id *newid;
4495	int myid, error, size;
4496
4497	BUG_ON(!ss->use_id);
4498
4499	size = sizeof(newid) + sizeof(unsigned short) (depth + 1);
4500	newid = kzalloc(size, GFP_KERNEL);
4501	if (!newid)
4502	return ERR_PTR(-ENOMEM);
4503	/* get id */
4504	if (unlikely(!idr_pre_get(&ss->idr, GFP_KERNEL))) {
4505	error = -ENOMEM;
4506	goto err_out;
4507	}
4508	spin_lock(&ss->id_lock);
4509	/* Don't use 0. allocates an ID of 1-65535 */
4510	error = idr_get_new_above(&ss->idr, newid, 1, &myid);
4511	spin_unlock(&ss->id_lock);
4512
4513	/* Returns error when there are no free spaces for new ID.*/
4514	if (error) {
4515	error = -ENOSPC;
4516	goto err_out;
4517	}
4518	if (myid > CSS_ID_MAX)
4519	goto remove_idr;
4520
4521	newid->id = myid;
4522	newid->depth = depth;
4523	return newid;
4524	remove_idr:
4525	error = -ENOSPC;
4526	spin_lock(&ss->id_lock);
4527	idr_remove(&ss->idr, myid);
4528	spin_unlock(&ss->id_lock);
4529	err_out:
4530	kfree(newid);
4531	return ERR_PTR(error);
4532
4533	}
4534
4535	static int __init_or_module cgroup_init_idr(struct cgroup_subsys *ss,
4536	struct cgroup_subsys_state *rootcss)
4537	{
4538	struct css_id *newid;
4539
4540	spin_lock_init(&ss->id_lock);
4541	idr_init(&ss->idr);
4542
4543	newid = get_new_cssid(ss, 0);
4544	if (IS_ERR(newid))
4545	return PTR_ERR(newid);
4546
4547	newid->stack[0] = newid->id;
4548	newid->css = rootcss;
4549	rootcss->id = newid;
4550	return 0;
4551	}
4552
4553	static int alloc_css_id(struct cgroup_subsys ss, struct cgroup parent,
4554	struct cgroup *child)
4555	{
4556	int subsys_id, i, depth = 0;
4557	struct cgroup_subsys_state parent_css, child_css;
4558	struct css_id child_id, parent_id = NULL;
4559
4560	subsys_id = ss->subsys_id;
4561	parent_css = parent->subsys[subsys_id];
4562	child_css = child->subsys[subsys_id];
4563	depth = css_depth(parent_css) + 1;
4564	parent_id = parent_css->id;
4565
4566	child_id = get_new_cssid(ss, depth);
4567	if (IS_ERR(child_id))
4568	return PTR_ERR(child_id);
4569
4570	for (i = 0; i < depth; i++)
4571	child_id->stack[i] = parent_id->stack[i];
4572	child_id->stack[depth] = child_id->id;
4573	/*
4574	* child_id->css pointer will be set after this cgroup is available
4575	* see cgroup_populate_dir()
4576	*/
4577	rcu_assign_pointer(child_css->id, child_id);
4578
4579	return 0;
4580	}
4581
4582	/**
4583	* css_lookup - lookup css by id
4584	* @ss: cgroup subsys to be looked into.
4585	* @id: the id
4586	*
4587	* Returns pointer to cgroup_subsys_state if there is valid one with id.
4588	* NULL if not. Should be called under rcu_read_lock()
4589	*/
4590	struct cgroup_subsys_state css_lookup(struct cgroup_subsys ss, int id)
4591	{
4592	struct css_id *cssid = NULL;
4593
4594	BUG_ON(!ss->use_id);
4595	cssid = idr_find(&ss->idr, id);
4596
4597	if (unlikely(!cssid))
4598	return NULL;
4599
4600	return rcu_dereference(cssid->css);
4601	}
4602	EXPORT_SYMBOL_GPL(css_lookup);
4603
4604	/**
4605	* css_get_next - lookup next cgroup under specified hierarchy.
4606	* @ss: pointer to subsystem
4607	* @id: current position of iteration.
4608	* @root: pointer to css. search tree under this.
4609	* @foundid: position of found object.
4610	*
4611	* Search next css under the specified hierarchy of rootid. Calling under
4612	* rcu_read_lock() is necessary. Returns NULL if it reaches the end.
4613	*/
4614	struct cgroup_subsys_state *
4615	css_get_next(struct cgroup_subsys *ss, int id,
4616	struct cgroup_subsys_state root, int foundid)
4617	{
4618	struct cgroup_subsys_state *ret = NULL;
4619	struct css_id *tmp;
4620	int tmpid;
4621	int rootid = css_id(root);
4622	int depth = css_depth(root);
4623
4624	if (!rootid)
4625	return NULL;
4626
4627	BUG_ON(!ss->use_id);
4628	/* fill start point for scan */
4629	tmpid = id;
4630	while (1) {
4631	/*
4632	* scan next entry from bitmap(tree), tmpid is updated after
4633	* idr_get_next().
4634	*/
4635	spin_lock(&ss->id_lock);
4636	tmp = idr_get_next(&ss->idr, &tmpid);
4637	spin_unlock(&ss->id_lock);
4638
4639	if (!tmp)
4640	break;
4641	if (tmp->depth >= depth && tmp->stack[depth] == rootid) {
4642	ret = rcu_dereference(tmp->css);
4643	if (ret) {
4644	*foundid = tmpid;
4645	break;
4646	}
4647	}
4648	/* continue to scan from next id */
4649	tmpid = tmpid + 1;
4650	}
4651	return ret;
4652	}
4653
4654	#ifdef CONFIG_CGROUP_DEBUG
4655	static struct cgroup_subsys_state debug_create(struct cgroup_subsys ss,
4656	struct cgroup *cont)
4657	{
4658	struct cgroup_subsys_state css = kzalloc(sizeof(css), GFP_KERNEL);
4659
4660	if (!css)
4661	return ERR_PTR(-ENOMEM);
4662
4663	return css;
4664	}
4665
4666	static void debug_destroy(struct cgroup_subsys ss, struct cgroup cont)
4667	{
4668	kfree(cont->subsys[debug_subsys_id]);
4669	}
4670
4671	static u64 cgroup_refcount_read(struct cgroup cont, struct cftype cft)
4672	{
4673	return atomic_read(&cont->count);
4674	}
4675
4676	static u64 debug_taskcount_read(struct cgroup cont, struct cftype cft)
4677	{
4678	return cgroup_task_count(cont);
4679	}
4680
4681	static u64 current_css_set_read(struct cgroup cont, struct cftype cft)
4682	{
4683	return (u64)(unsigned long)current->cgroups;
4684	}
4685
4686	static u64 current_css_set_refcount_read(struct cgroup *cont,
4687	struct cftype *cft)
4688	{
4689	u64 count;
4690
4691	rcu_read_lock();
4692	count = atomic_read(&current->cgroups->refcount);
4693	rcu_read_unlock();
4694	return count;
4695	}
4696
4697	static int current_css_set_cg_links_read(struct cgroup *cont,
4698	struct cftype *cft,
4699	struct seq_file *seq)
4700	{
4701	struct cg_cgroup_link *link;
4702	struct css_set *cg;
4703
4704	read_lock(&css_set_lock);
4705	rcu_read_lock();
4706	cg = rcu_dereference(current->cgroups);
4707	list_for_each_entry(link, &cg->cg_links, cg_link_list) {
4708	struct cgroup *c = link->cgrp;
4709	const char *name;
4710
4711	if (c->dentry)
4712	name = c->dentry->d_name.name;
4713	else
4714	name = "?";
4715	seq_printf(seq, "Root %d group %s\n",
4716	c->root->hierarchy_id, name);
4717	}
4718	rcu_read_unlock();
4719	read_unlock(&css_set_lock);
4720	return 0;
4721	}
4722
4723	#define MAX_TASKS_SHOWN_PER_CSS 25
4724	static int cgroup_css_links_read(struct cgroup *cont,
4725	struct cftype *cft,
4726	struct seq_file *seq)
4727	{
4728	struct cg_cgroup_link *link;
4729
4730	read_lock(&css_set_lock);
4731	list_for_each_entry(link, &cont->css_sets, cgrp_link_list) {
4732	struct css_set *cg = link->cg;
4733	struct task_struct *task;
4734	int count = 0;
4735	seq_printf(seq, "css_set %p\n", cg);
4736	list_for_each_entry(task, &cg->tasks, cg_list) {
4737	if (count++ > MAX_TASKS_SHOWN_PER_CSS) {
4738	seq_puts(seq, " ...\n");
4739	break;
4740	} else {
4741	seq_printf(seq, " task %d\n",
4742	task_pid_vnr(task));
4743	}
4744	}
4745	}
4746	read_unlock(&css_set_lock);
4747	return 0;
4748	}
4749
4750	static u64 releasable_read(struct cgroup cgrp, struct cftype cft)
4751	{
4752	return test_bit(CGRP_RELEASABLE, &cgrp->flags);
4753	}
4754
4755	static struct cftype debug_files[] = {
4756	{
4757	.name = "cgroup_refcount",
4758	.read_u64 = cgroup_refcount_read,
4759	},
4760	{
4761	.name = "taskcount",
4762	.read_u64 = debug_taskcount_read,
4763	},
4764
4765	{
4766	.name = "current_css_set",
4767	.read_u64 = current_css_set_read,
4768	},
4769
4770	{
4771	.name = "current_css_set_refcount",
4772	.read_u64 = current_css_set_refcount_read,
4773	},
4774
4775	{
4776	.name = "current_css_set_cg_links",
4777	.read_seq_string = current_css_set_cg_links_read,
4778	},
4779
4780	{
4781	.name = "cgroup_css_links",
4782	.read_seq_string = cgroup_css_links_read,
4783	},
4784
4785	{
4786	.name = "releasable",
4787	.read_u64 = releasable_read,
4788	},
4789	};
4790
4791	static int debug_populate(struct cgroup_subsys ss, struct cgroup cont)
4792	{
4793	return cgroup_add_files(cont, ss, debug_files,
4794	ARRAY_SIZE(debug_files));
4795	}
4796
4797	struct cgroup_subsys debug_subsys = {
4798	.name = "debug",
4799	.create = debug_create,
4800	.destroy = debug_destroy,
4801	.populate = debug_populate,
4802	.subsys_id = debug_subsys_id,
4803	};
4804	#endif /* CONFIG_CGROUP_DEBUG */
4805

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/cgroup.c

interactive