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