Merge tag 'linux-kselftest-4.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31 #include <linux/cgroup.h>
32 #include <linux/cred.h>
33 #include <linux/ctype.h>
34 #include <linux/errno.h>
35 #include <linux/init_task.h>
36 #include <linux/kernel.h>
37 #include <linux/list.h>
38 #include <linux/magic.h>
39 #include <linux/mm.h>
40 #include <linux/mutex.h>
41 #include <linux/mount.h>
42 #include <linux/pagemap.h>
43 #include <linux/proc_fs.h>
44 #include <linux/rcupdate.h>
45 #include <linux/sched.h>
46 #include <linux/slab.h>
47 #include <linux/spinlock.h>
48 #include <linux/percpu-rwsem.h>
49 #include <linux/string.h>
50 #include <linux/sort.h>
51 #include <linux/kmod.h>
52 #include <linux/delayacct.h>
53 #include <linux/cgroupstats.h>
54 #include <linux/hashtable.h>
55 #include <linux/pid_namespace.h>
56 #include <linux/idr.h>
57 #include <linux/vmalloc.h> /* TODO: replace with more sophisticated array */
58 #include <linux/kthread.h>
59 #include <linux/delay.h>
60 #include <linux/atomic.h>
61 #include <net/sock.h>
62
63 /*
64  * pidlists linger the following amount before being destroyed.  The goal
65  * is avoiding frequent destruction in the middle of consecutive read calls
66  * Expiring in the middle is a performance problem not a correctness one.
67  * 1 sec should be enough.
68  */
69 #define CGROUP_PIDLIST_DESTROY_DELAY    HZ
70
71 #define CGROUP_FILE_NAME_MAX            (MAX_CGROUP_TYPE_NAMELEN +      \
72                                          MAX_CFTYPE_NAME + 2)
73
74 /*
75  * cgroup_mutex is the master lock.  Any modification to cgroup or its
76  * hierarchy must be performed while holding it.
77  *
78  * css_set_lock protects task->cgroups pointer, the list of css_set
79  * objects, and the chain of tasks off each css_set.
80  *
81  * These locks are exported if CONFIG_PROVE_RCU so that accessors in
82  * cgroup.h can use them for lockdep annotations.
83  */
84 #ifdef CONFIG_PROVE_RCU
85 DEFINE_MUTEX(cgroup_mutex);
86 DEFINE_SPINLOCK(css_set_lock);
87 EXPORT_SYMBOL_GPL(cgroup_mutex);
88 EXPORT_SYMBOL_GPL(css_set_lock);
89 #else
90 static DEFINE_MUTEX(cgroup_mutex);
91 static DEFINE_SPINLOCK(css_set_lock);
92 #endif
93
94 /*
95  * Protects cgroup_idr and css_idr so that IDs can be released without
96  * grabbing cgroup_mutex.
97  */
98 static DEFINE_SPINLOCK(cgroup_idr_lock);
99
100 /*
101  * Protects cgroup_file->kn for !self csses.  It synchronizes notifications
102  * against file removal/re-creation across css hiding.
103  */
104 static DEFINE_SPINLOCK(cgroup_file_kn_lock);
105
106 /*
107  * Protects cgroup_subsys->release_agent_path.  Modifying it also requires
108  * cgroup_mutex.  Reading requires either cgroup_mutex or this spinlock.
109  */
110 static DEFINE_SPINLOCK(release_agent_path_lock);
111
112 struct percpu_rw_semaphore cgroup_threadgroup_rwsem;
113
114 #define cgroup_assert_mutex_or_rcu_locked()                             \
115         RCU_LOCKDEP_WARN(!rcu_read_lock_held() &&                       \
116                            !lockdep_is_held(&cgroup_mutex),             \
117                            "cgroup_mutex or RCU read lock required");
118
119 /*
120  * cgroup destruction makes heavy use of work items and there can be a lot
121  * of concurrent destructions.  Use a separate workqueue so that cgroup
122  * destruction work items don't end up filling up max_active of system_wq
123  * which may lead to deadlock.
124  */
125 static struct workqueue_struct *cgroup_destroy_wq;
126
127 /*
128  * pidlist destructions need to be flushed on cgroup destruction.  Use a
129  * separate workqueue as flush domain.
130  */
131 static struct workqueue_struct *cgroup_pidlist_destroy_wq;
132
133 /* generate an array of cgroup subsystem pointers */
134 #define SUBSYS(_x) [_x ## _cgrp_id] = &_x ## _cgrp_subsys,
135 static struct cgroup_subsys *cgroup_subsys[] = {
136 #include <linux/cgroup_subsys.h>
137 };
138 #undef SUBSYS
139
140 /* array of cgroup subsystem names */
141 #define SUBSYS(_x) [_x ## _cgrp_id] = #_x,
142 static const char *cgroup_subsys_name[] = {
143 #include <linux/cgroup_subsys.h>
144 };
145 #undef SUBSYS
146
147 /* array of static_keys for cgroup_subsys_enabled() and cgroup_subsys_on_dfl() */
148 #define SUBSYS(_x)                                                              \
149         DEFINE_STATIC_KEY_TRUE(_x ## _cgrp_subsys_enabled_key);                 \
150         DEFINE_STATIC_KEY_TRUE(_x ## _cgrp_subsys_on_dfl_key);                  \
151         EXPORT_SYMBOL_GPL(_x ## _cgrp_subsys_enabled_key);                      \
152         EXPORT_SYMBOL_GPL(_x ## _cgrp_subsys_on_dfl_key);
153 #include <linux/cgroup_subsys.h>
154 #undef SUBSYS
155
156 #define SUBSYS(_x) [_x ## _cgrp_id] = &_x ## _cgrp_subsys_enabled_key,
157 static struct static_key_true *cgroup_subsys_enabled_key[] = {
158 #include <linux/cgroup_subsys.h>
159 };
160 #undef SUBSYS
161
162 #define SUBSYS(_x) [_x ## _cgrp_id] = &_x ## _cgrp_subsys_on_dfl_key,
163 static struct static_key_true *cgroup_subsys_on_dfl_key[] = {
164 #include <linux/cgroup_subsys.h>
165 };
166 #undef SUBSYS
167
168 /*
169  * The default hierarchy, reserved for the subsystems that are otherwise
170  * unattached - it never has more than a single cgroup, and all tasks are
171  * part of that cgroup.
172  */
173 struct cgroup_root cgrp_dfl_root;
174 EXPORT_SYMBOL_GPL(cgrp_dfl_root);
175
176 /*
177  * The default hierarchy always exists but is hidden until mounted for the
178  * first time.  This is for backward compatibility.
179  */
180 static bool cgrp_dfl_root_visible;
181
182 /* some controllers are not supported in the default hierarchy */
183 static unsigned long cgrp_dfl_root_inhibit_ss_mask;
184
185 /* The list of hierarchy roots */
186
187 static LIST_HEAD(cgroup_roots);
188 static int cgroup_root_count;
189
190 /* hierarchy ID allocation and mapping, protected by cgroup_mutex */
191 static DEFINE_IDR(cgroup_hierarchy_idr);
192
193 /*
194  * Assign a monotonically increasing serial number to csses.  It guarantees
195  * cgroups with bigger numbers are newer than those with smaller numbers.
196  * Also, as csses are always appended to the parent's ->children list, it
197  * guarantees that sibling csses are always sorted in the ascending serial
198  * number order on the list.  Protected by cgroup_mutex.
199  */
200 static u64 css_serial_nr_next = 1;
201
202 /*
203  * These bitmask flags indicate whether tasks in the fork and exit paths have
204  * fork/exit handlers to call. This avoids us having to do extra work in the
205  * fork/exit path to check which subsystems have fork/exit callbacks.
206  */
207 static unsigned long have_fork_callback __read_mostly;
208 static unsigned long have_exit_callback __read_mostly;
209 static unsigned long have_free_callback __read_mostly;
210
211 /* Ditto for the can_fork callback. */
212 static unsigned long have_canfork_callback __read_mostly;
213
214 static struct file_system_type cgroup2_fs_type;
215 static struct cftype cgroup_dfl_base_files[];
216 static struct cftype cgroup_legacy_base_files[];
217
218 static int rebind_subsystems(struct cgroup_root *dst_root,
219                              unsigned long ss_mask);
220 static void css_task_iter_advance(struct css_task_iter *it);
221 static int cgroup_destroy_locked(struct cgroup *cgrp);
222 static int create_css(struct cgroup *cgrp, struct cgroup_subsys *ss,
223                       bool visible);
224 static void css_release(struct percpu_ref *ref);
225 static void kill_css(struct cgroup_subsys_state *css);
226 static int cgroup_addrm_files(struct cgroup_subsys_state *css,
227                               struct cgroup *cgrp, struct cftype cfts[],
228                               bool is_add);
229
230 /**
231  * cgroup_ssid_enabled - cgroup subsys enabled test by subsys ID
232  * @ssid: subsys ID of interest
233  *
234  * cgroup_subsys_enabled() can only be used with literal subsys names which
235  * is fine for individual subsystems but unsuitable for cgroup core.  This
236  * is slower static_key_enabled() based test indexed by @ssid.
237  */
238 static bool cgroup_ssid_enabled(int ssid)
239 {
240         return static_key_enabled(cgroup_subsys_enabled_key[ssid]);
241 }
242
243 /**
244  * cgroup_on_dfl - test whether a cgroup is on the default hierarchy
245  * @cgrp: the cgroup of interest
246  *
247  * The default hierarchy is the v2 interface of cgroup and this function
248  * can be used to test whether a cgroup is on the default hierarchy for
249  * cases where a subsystem should behave differnetly depending on the
250  * interface version.
251  *
252  * The set of behaviors which change on the default hierarchy are still
253  * being determined and the mount option is prefixed with __DEVEL__.
254  *
255  * List of changed behaviors:
256  *
257  * - Mount options "noprefix", "xattr", "clone_children", "release_agent"
258  *   and "name" are disallowed.
259  *
260  * - When mounting an existing superblock, mount options should match.
261  *
262  * - Remount is disallowed.
263  *
264  * - rename(2) is disallowed.
265  *
266  * - "tasks" is removed.  Everything should be at process granularity.  Use
267  *   "cgroup.procs" instead.
268  *
269  * - "cgroup.procs" is not sorted.  pids will be unique unless they got
270  *   recycled inbetween reads.
271  *
272  * - "release_agent" and "notify_on_release" are removed.  Replacement
273  *   notification mechanism will be implemented.
274  *
275  * - "cgroup.clone_children" is removed.
276  *
277  * - "cgroup.subtree_populated" is available.  Its value is 0 if the cgroup
278  *   and its descendants contain no task; otherwise, 1.  The file also
279  *   generates kernfs notification which can be monitored through poll and
280  *   [di]notify when the value of the file changes.
281  *
282  * - cpuset: tasks will be kept in empty cpusets when hotplug happens and
283  *   take masks of ancestors with non-empty cpus/mems, instead of being
284  *   moved to an ancestor.
285  *
286  * - cpuset: a task can be moved into an empty cpuset, and again it takes
287  *   masks of ancestors.
288  *
289  * - memcg: use_hierarchy is on by default and the cgroup file for the flag
290  *   is not created.
291  *
292  * - blkcg: blk-throttle becomes properly hierarchical.
293  *
294  * - debug: disallowed on the default hierarchy.
295  */
296 static bool cgroup_on_dfl(const struct cgroup *cgrp)
297 {
298         return cgrp->root == &cgrp_dfl_root;
299 }
300
301 /* IDR wrappers which synchronize using cgroup_idr_lock */
302 static int cgroup_idr_alloc(struct idr *idr, void *ptr, int start, int end,
303                             gfp_t gfp_mask)
304 {
305         int ret;
306
307         idr_preload(gfp_mask);
308         spin_lock_bh(&cgroup_idr_lock);
309         ret = idr_alloc(idr, ptr, start, end, gfp_mask & ~__GFP_DIRECT_RECLAIM);
310         spin_unlock_bh(&cgroup_idr_lock);
311         idr_preload_end();
312         return ret;
313 }
314
315 static void *cgroup_idr_replace(struct idr *idr, void *ptr, int id)
316 {
317         void *ret;
318
319         spin_lock_bh(&cgroup_idr_lock);
320         ret = idr_replace(idr, ptr, id);
321         spin_unlock_bh(&cgroup_idr_lock);
322         return ret;
323 }
324
325 static void cgroup_idr_remove(struct idr *idr, int id)
326 {
327         spin_lock_bh(&cgroup_idr_lock);
328         idr_remove(idr, id);
329         spin_unlock_bh(&cgroup_idr_lock);
330 }
331
332 static struct cgroup *cgroup_parent(struct cgroup *cgrp)
333 {
334         struct cgroup_subsys_state *parent_css = cgrp->self.parent;
335
336         if (parent_css)
337                 return container_of(parent_css, struct cgroup, self);
338         return NULL;
339 }
340
341 /**
342  * cgroup_css - obtain a cgroup's css for the specified subsystem
343  * @cgrp: the cgroup of interest
344  * @ss: the subsystem of interest (%NULL returns @cgrp->self)
345  *
346  * Return @cgrp's css (cgroup_subsys_state) associated with @ss.  This
347  * function must be called either under cgroup_mutex or rcu_read_lock() and
348  * the caller is responsible for pinning the returned css if it wants to
349  * keep accessing it outside the said locks.  This function may return
350  * %NULL if @cgrp doesn't have @subsys_id enabled.
351  */
352 static struct cgroup_subsys_state *cgroup_css(struct cgroup *cgrp,
353                                               struct cgroup_subsys *ss)
354 {
355         if (ss)
356                 return rcu_dereference_check(cgrp->subsys[ss->id],
357                                         lockdep_is_held(&cgroup_mutex));
358         else
359                 return &cgrp->self;
360 }
361
362 /**
363  * cgroup_e_css - obtain a cgroup's effective css for the specified subsystem
364  * @cgrp: the cgroup of interest
365  * @ss: the subsystem of interest (%NULL returns @cgrp->self)
366  *
367  * Similar to cgroup_css() but returns the effective css, which is defined
368  * as the matching css of the nearest ancestor including self which has @ss
369  * enabled.  If @ss is associated with the hierarchy @cgrp is on, this
370  * function is guaranteed to return non-NULL css.
371  */
372 static struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgrp,
373                                                 struct cgroup_subsys *ss)
374 {
375         lockdep_assert_held(&cgroup_mutex);
376
377         if (!ss)
378                 return &cgrp->self;
379
380         if (!(cgrp->root->subsys_mask & (1 << ss->id)))
381                 return NULL;
382
383         /*
384          * This function is used while updating css associations and thus
385          * can't test the csses directly.  Use ->child_subsys_mask.
386          */
387         while (cgroup_parent(cgrp) &&
388                !(cgroup_parent(cgrp)->child_subsys_mask & (1 << ss->id)))
389                 cgrp = cgroup_parent(cgrp);
390
391         return cgroup_css(cgrp, ss);
392 }
393
394 /**
395  * cgroup_get_e_css - get a cgroup's effective css for the specified subsystem
396  * @cgrp: the cgroup of interest
397  * @ss: the subsystem of interest
398  *
399  * Find and get the effective css of @cgrp for @ss.  The effective css is
400  * defined as the matching css of the nearest ancestor including self which
401  * has @ss enabled.  If @ss is not mounted on the hierarchy @cgrp is on,
402  * the root css is returned, so this function always returns a valid css.
403  * The returned css must be put using css_put().
404  */
405 struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgrp,
406                                              struct cgroup_subsys *ss)
407 {
408         struct cgroup_subsys_state *css;
409
410         rcu_read_lock();
411
412         do {
413                 css = cgroup_css(cgrp, ss);
414
415                 if (css && css_tryget_online(css))
416                         goto out_unlock;
417                 cgrp = cgroup_parent(cgrp);
418         } while (cgrp);
419
420         css = init_css_set.subsys[ss->id];
421         css_get(css);
422 out_unlock:
423         rcu_read_unlock();
424         return css;
425 }
426
427 /* convenient tests for these bits */
428 static inline bool cgroup_is_dead(const struct cgroup *cgrp)
429 {
430         return !(cgrp->self.flags & CSS_ONLINE);
431 }
432
433 static void cgroup_get(struct cgroup *cgrp)
434 {
435         WARN_ON_ONCE(cgroup_is_dead(cgrp));
436         css_get(&cgrp->self);
437 }
438
439 static bool cgroup_tryget(struct cgroup *cgrp)
440 {
441         return css_tryget(&cgrp->self);
442 }
443
444 struct cgroup_subsys_state *of_css(struct kernfs_open_file *of)
445 {
446         struct cgroup *cgrp = of->kn->parent->priv;
447         struct cftype *cft = of_cft(of);
448
449         /*
450          * This is open and unprotected implementation of cgroup_css().
451          * seq_css() is only called from a kernfs file operation which has
452          * an active reference on the file.  Because all the subsystem
453          * files are drained before a css is disassociated with a cgroup,
454          * the matching css from the cgroup's subsys table is guaranteed to
455          * be and stay valid until the enclosing operation is complete.
456          */
457         if (cft->ss)
458                 return rcu_dereference_raw(cgrp->subsys[cft->ss->id]);
459         else
460                 return &cgrp->self;
461 }
462 EXPORT_SYMBOL_GPL(of_css);
463
464 static int notify_on_release(const struct cgroup *cgrp)
465 {
466         return test_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
467 }
468
469 /**
470  * for_each_css - iterate all css's of a cgroup
471  * @css: the iteration cursor
472  * @ssid: the index of the subsystem, CGROUP_SUBSYS_COUNT after reaching the end
473  * @cgrp: the target cgroup to iterate css's of
474  *
475  * Should be called under cgroup_[tree_]mutex.
476  */
477 #define for_each_css(css, ssid, cgrp)                                   \
478         for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT; (ssid)++)        \
479                 if (!((css) = rcu_dereference_check(                    \
480                                 (cgrp)->subsys[(ssid)],                 \
481                                 lockdep_is_held(&cgroup_mutex)))) { }   \
482                 else
483
484 /**
485  * for_each_e_css - iterate all effective css's of a cgroup
486  * @css: the iteration cursor
487  * @ssid: the index of the subsystem, CGROUP_SUBSYS_COUNT after reaching the end
488  * @cgrp: the target cgroup to iterate css's of
489  *
490  * Should be called under cgroup_[tree_]mutex.
491  */
492 #define for_each_e_css(css, ssid, cgrp)                                 \
493         for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT; (ssid)++)        \
494                 if (!((css) = cgroup_e_css(cgrp, cgroup_subsys[(ssid)]))) \
495                         ;                                               \
496                 else
497
498 /**
499  * for_each_subsys - iterate all enabled cgroup subsystems
500  * @ss: the iteration cursor
501  * @ssid: the index of @ss, CGROUP_SUBSYS_COUNT after reaching the end
502  */
503 #define for_each_subsys(ss, ssid)                                       \
504         for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT &&                \
505              (((ss) = cgroup_subsys[ssid]) || true); (ssid)++)
506
507 /**
508  * for_each_subsys_which - filter for_each_subsys with a bitmask
509  * @ss: the iteration cursor
510  * @ssid: the index of @ss, CGROUP_SUBSYS_COUNT after reaching the end
511  * @ss_maskp: a pointer to the bitmask
512  *
513  * The block will only run for cases where the ssid-th bit (1 << ssid) of
514  * mask is set to 1.
515  */
516 #define for_each_subsys_which(ss, ssid, ss_maskp)                       \
517         if (!CGROUP_SUBSYS_COUNT) /* to avoid spurious gcc warning */   \
518                 (ssid) = 0;                                             \
519         else                                                            \
520                 for_each_set_bit(ssid, ss_maskp, CGROUP_SUBSYS_COUNT)   \
521                         if (((ss) = cgroup_subsys[ssid]) && false)      \
522                                 break;                                  \
523                         else
524
525 /* iterate across the hierarchies */
526 #define for_each_root(root)                                             \
527         list_for_each_entry((root), &cgroup_roots, root_list)
528
529 /* iterate over child cgrps, lock should be held throughout iteration */
530 #define cgroup_for_each_live_child(child, cgrp)                         \
531         list_for_each_entry((child), &(cgrp)->self.children, self.sibling) \
532                 if (({ lockdep_assert_held(&cgroup_mutex);              \
533                        cgroup_is_dead(child); }))                       \
534                         ;                                               \
535                 else
536
537 static void cgroup_release_agent(struct work_struct *work);
538 static void check_for_release(struct cgroup *cgrp);
539
540 /*
541  * A cgroup can be associated with multiple css_sets as different tasks may
542  * belong to different cgroups on different hierarchies.  In the other
543  * direction, a css_set is naturally associated with multiple cgroups.
544  * This M:N relationship is represented by the following link structure
545  * which exists for each association and allows traversing the associations
546  * from both sides.
547  */
548 struct cgrp_cset_link {
549         /* the cgroup and css_set this link associates */
550         struct cgroup           *cgrp;
551         struct css_set          *cset;
552
553         /* list of cgrp_cset_links anchored at cgrp->cset_links */
554         struct list_head        cset_link;
555
556         /* list of cgrp_cset_links anchored at css_set->cgrp_links */
557         struct list_head        cgrp_link;
558 };
559
560 /*
561  * The default css_set - used by init and its children prior to any
562  * hierarchies being mounted. It contains a pointer to the root state
563  * for each subsystem. Also used to anchor the list of css_sets. Not
564  * reference-counted, to improve performance when child cgroups
565  * haven't been created.
566  */
567 struct css_set init_css_set = {
568         .refcount               = ATOMIC_INIT(1),
569         .cgrp_links             = LIST_HEAD_INIT(init_css_set.cgrp_links),
570         .tasks                  = LIST_HEAD_INIT(init_css_set.tasks),
571         .mg_tasks               = LIST_HEAD_INIT(init_css_set.mg_tasks),
572         .mg_preload_node        = LIST_HEAD_INIT(init_css_set.mg_preload_node),
573         .mg_node                = LIST_HEAD_INIT(init_css_set.mg_node),
574         .task_iters             = LIST_HEAD_INIT(init_css_set.task_iters),
575 };
576
577 static int css_set_count        = 1;    /* 1 for init_css_set */
578
579 /**
580  * css_set_populated - does a css_set contain any tasks?
581  * @cset: target css_set
582  */
583 static bool css_set_populated(struct css_set *cset)
584 {
585         lockdep_assert_held(&css_set_lock);
586
587         return !list_empty(&cset->tasks) || !list_empty(&cset->mg_tasks);
588 }
589
590 /**
591  * cgroup_update_populated - updated populated count of a cgroup
592  * @cgrp: the target cgroup
593  * @populated: inc or dec populated count
594  *
595  * One of the css_sets associated with @cgrp is either getting its first
596  * task or losing the last.  Update @cgrp->populated_cnt accordingly.  The
597  * count is propagated towards root so that a given cgroup's populated_cnt
598  * is zero iff the cgroup and all its descendants don't contain any tasks.
599  *
600  * @cgrp's interface file "cgroup.populated" is zero if
601  * @cgrp->populated_cnt is zero and 1 otherwise.  When @cgrp->populated_cnt
602  * changes from or to zero, userland is notified that the content of the
603  * interface file has changed.  This can be used to detect when @cgrp and
604  * its descendants become populated or empty.
605  */
606 static void cgroup_update_populated(struct cgroup *cgrp, bool populated)
607 {
608         lockdep_assert_held(&css_set_lock);
609
610         do {
611                 bool trigger;
612
613                 if (populated)
614                         trigger = !cgrp->populated_cnt++;
615                 else
616                         trigger = !--cgrp->populated_cnt;
617
618                 if (!trigger)
619                         break;
620
621                 check_for_release(cgrp);
622                 cgroup_file_notify(&cgrp->events_file);
623
624                 cgrp = cgroup_parent(cgrp);
625         } while (cgrp);
626 }
627
628 /**
629  * css_set_update_populated - update populated state of a css_set
630  * @cset: target css_set
631  * @populated: whether @cset is populated or depopulated
632  *
633  * @cset is either getting the first task or losing the last.  Update the
634  * ->populated_cnt of all associated cgroups accordingly.
635  */
636 static void css_set_update_populated(struct css_set *cset, bool populated)
637 {
638         struct cgrp_cset_link *link;
639
640         lockdep_assert_held(&css_set_lock);
641
642         list_for_each_entry(link, &cset->cgrp_links, cgrp_link)
643                 cgroup_update_populated(link->cgrp, populated);
644 }
645
646 /**
647  * css_set_move_task - move a task from one css_set to another
648  * @task: task being moved
649  * @from_cset: css_set @task currently belongs to (may be NULL)
650  * @to_cset: new css_set @task is being moved to (may be NULL)
651  * @use_mg_tasks: move to @to_cset->mg_tasks instead of ->tasks
652  *
653  * Move @task from @from_cset to @to_cset.  If @task didn't belong to any
654  * css_set, @from_cset can be NULL.  If @task is being disassociated
655  * instead of moved, @to_cset can be NULL.
656  *
657  * This function automatically handles populated_cnt updates and
658  * css_task_iter adjustments but the caller is responsible for managing
659  * @from_cset and @to_cset's reference counts.
660  */
661 static void css_set_move_task(struct task_struct *task,
662                               struct css_set *from_cset, struct css_set *to_cset,
663                               bool use_mg_tasks)
664 {
665         lockdep_assert_held(&css_set_lock);
666
667         if (from_cset) {
668                 struct css_task_iter *it, *pos;
669
670                 WARN_ON_ONCE(list_empty(&task->cg_list));
671
672                 /*
673                  * @task is leaving, advance task iterators which are
674                  * pointing to it so that they can resume at the next
675                  * position.  Advancing an iterator might remove it from
676                  * the list, use safe walk.  See css_task_iter_advance*()
677                  * for details.
678                  */
679                 list_for_each_entry_safe(it, pos, &from_cset->task_iters,
680                                          iters_node)
681                         if (it->task_pos == &task->cg_list)
682                                 css_task_iter_advance(it);
683
684                 list_del_init(&task->cg_list);
685                 if (!css_set_populated(from_cset))
686                         css_set_update_populated(from_cset, false);
687         } else {
688                 WARN_ON_ONCE(!list_empty(&task->cg_list));
689         }
690
691         if (to_cset) {
692                 /*
693                  * We are synchronized through cgroup_threadgroup_rwsem
694                  * against PF_EXITING setting such that we can't race
695                  * against cgroup_exit() changing the css_set to
696                  * init_css_set and dropping the old one.
697                  */
698                 WARN_ON_ONCE(task->flags & PF_EXITING);
699
700                 if (!css_set_populated(to_cset))
701                         css_set_update_populated(to_cset, true);
702                 rcu_assign_pointer(task->cgroups, to_cset);
703                 list_add_tail(&task->cg_list, use_mg_tasks ? &to_cset->mg_tasks :
704                                                              &to_cset->tasks);
705         }
706 }
707
708 /*
709  * hash table for cgroup groups. This improves the performance to find
710  * an existing css_set. This hash doesn't (currently) take into
711  * account cgroups in empty hierarchies.
712  */
713 #define CSS_SET_HASH_BITS       7
714 static DEFINE_HASHTABLE(css_set_table, CSS_SET_HASH_BITS);
715
716 static unsigned long css_set_hash(struct cgroup_subsys_state *css[])
717 {
718         unsigned long key = 0UL;
719         struct cgroup_subsys *ss;
720         int i;
721
722         for_each_subsys(ss, i)
723                 key += (unsigned long)css[i];
724         key = (key >> 16) ^ key;
725
726         return key;
727 }
728
729 static void put_css_set_locked(struct css_set *cset)
730 {
731         struct cgrp_cset_link *link, *tmp_link;
732         struct cgroup_subsys *ss;
733         int ssid;
734
735         lockdep_assert_held(&css_set_lock);
736
737         if (!atomic_dec_and_test(&cset->refcount))
738                 return;
739
740         /* This css_set is dead. unlink it and release cgroup and css refs */
741         for_each_subsys(ss, ssid) {
742                 list_del(&cset->e_cset_node[ssid]);
743                 css_put(cset->subsys[ssid]);
744         }
745         hash_del(&cset->hlist);
746         css_set_count--;
747
748         list_for_each_entry_safe(link, tmp_link, &cset->cgrp_links, cgrp_link) {
749                 list_del(&link->cset_link);
750                 list_del(&link->cgrp_link);
751                 if (cgroup_parent(link->cgrp))
752                         cgroup_put(link->cgrp);
753                 kfree(link);
754         }
755
756         kfree_rcu(cset, rcu_head);
757 }
758
759 static void put_css_set(struct css_set *cset)
760 {
761         /*
762          * Ensure that the refcount doesn't hit zero while any readers
763          * can see it. Similar to atomic_dec_and_lock(), but for an
764          * rwlock
765          */
766         if (atomic_add_unless(&cset->refcount, -1, 1))
767                 return;
768
769         spin_lock_bh(&css_set_lock);
770         put_css_set_locked(cset);
771         spin_unlock_bh(&css_set_lock);
772 }
773
774 /*
775  * refcounted get/put for css_set objects
776  */
777 static inline void get_css_set(struct css_set *cset)
778 {
779         atomic_inc(&cset->refcount);
780 }
781
782 /**
783  * compare_css_sets - helper function for find_existing_css_set().
784  * @cset: candidate css_set being tested
785  * @old_cset: existing css_set for a task
786  * @new_cgrp: cgroup that's being entered by the task
787  * @template: desired set of css pointers in css_set (pre-calculated)
788  *
789  * Returns true if "cset" matches "old_cset" except for the hierarchy
790  * which "new_cgrp" belongs to, for which it should match "new_cgrp".
791  */
792 static bool compare_css_sets(struct css_set *cset,
793                              struct css_set *old_cset,
794                              struct cgroup *new_cgrp,
795                              struct cgroup_subsys_state *template[])
796 {
797         struct list_head *l1, *l2;
798
799         /*
800          * On the default hierarchy, there can be csets which are
801          * associated with the same set of cgroups but different csses.
802          * Let's first ensure that csses match.
803          */
804         if (memcmp(template, cset->subsys, sizeof(cset->subsys)))
805                 return false;
806
807         /*
808          * Compare cgroup pointers in order to distinguish between
809          * different cgroups in hierarchies.  As different cgroups may
810          * share the same effective css, this comparison is always
811          * necessary.
812          */
813         l1 = &cset->cgrp_links;
814         l2 = &old_cset->cgrp_links;
815         while (1) {
816                 struct cgrp_cset_link *link1, *link2;
817                 struct cgroup *cgrp1, *cgrp2;
818
819                 l1 = l1->next;
820                 l2 = l2->next;
821                 /* See if we reached the end - both lists are equal length. */
822                 if (l1 == &cset->cgrp_links) {
823                         BUG_ON(l2 != &old_cset->cgrp_links);
824                         break;
825                 } else {
826                         BUG_ON(l2 == &old_cset->cgrp_links);
827                 }
828                 /* Locate the cgroups associated with these links. */
829                 link1 = list_entry(l1, struct cgrp_cset_link, cgrp_link);
830                 link2 = list_entry(l2, struct cgrp_cset_link, cgrp_link);
831                 cgrp1 = link1->cgrp;
832                 cgrp2 = link2->cgrp;
833                 /* Hierarchies should be linked in the same order. */
834                 BUG_ON(cgrp1->root != cgrp2->root);
835
836                 /*
837                  * If this hierarchy is the hierarchy of the cgroup
838                  * that's changing, then we need to check that this
839                  * css_set points to the new cgroup; if it's any other
840                  * hierarchy, then this css_set should point to the
841                  * same cgroup as the old css_set.
842                  */
843                 if (cgrp1->root == new_cgrp->root) {
844                         if (cgrp1 != new_cgrp)
845                                 return false;
846                 } else {
847                         if (cgrp1 != cgrp2)
848                                 return false;
849                 }
850         }
851         return true;
852 }
853
854 /**
855  * find_existing_css_set - init css array and find the matching css_set
856  * @old_cset: the css_set that we're using before the cgroup transition
857  * @cgrp: the cgroup that we're moving into
858  * @template: out param for the new set of csses, should be clear on entry
859  */
860 static struct css_set *find_existing_css_set(struct css_set *old_cset,
861                                         struct cgroup *cgrp,
862                                         struct cgroup_subsys_state *template[])
863 {
864         struct cgroup_root *root = cgrp->root;
865         struct cgroup_subsys *ss;
866         struct css_set *cset;
867         unsigned long key;
868         int i;
869
870         /*
871          * Build the set of subsystem state objects that we want to see in the
872          * new css_set. while subsystems can change globally, the entries here
873          * won't change, so no need for locking.
874          */
875         for_each_subsys(ss, i) {
876                 if (root->subsys_mask & (1UL << i)) {
877                         /*
878                          * @ss is in this hierarchy, so we want the
879                          * effective css from @cgrp.
880                          */
881                         template[i] = cgroup_e_css(cgrp, ss);
882                 } else {
883                         /*
884                          * @ss is not in this hierarchy, so we don't want
885                          * to change the css.
886                          */
887                         template[i] = old_cset->subsys[i];
888                 }
889         }
890
891         key = css_set_hash(template);
892         hash_for_each_possible(css_set_table, cset, hlist, key) {
893                 if (!compare_css_sets(cset, old_cset, cgrp, template))
894                         continue;
895
896                 /* This css_set matches what we need */
897                 return cset;
898         }
899
900         /* No existing cgroup group matched */
901         return NULL;
902 }
903
904 static void free_cgrp_cset_links(struct list_head *links_to_free)
905 {
906         struct cgrp_cset_link *link, *tmp_link;
907
908         list_for_each_entry_safe(link, tmp_link, links_to_free, cset_link) {
909                 list_del(&link->cset_link);
910                 kfree(link);
911         }
912 }
913
914 /**
915  * allocate_cgrp_cset_links - allocate cgrp_cset_links
916  * @count: the number of links to allocate
917  * @tmp_links: list_head the allocated links are put on
918  *
919  * Allocate @count cgrp_cset_link structures and chain them on @tmp_links
920  * through ->cset_link.  Returns 0 on success or -errno.
921  */
922 static int allocate_cgrp_cset_links(int count, struct list_head *tmp_links)
923 {
924         struct cgrp_cset_link *link;
925         int i;
926
927         INIT_LIST_HEAD(tmp_links);
928
929         for (i = 0; i < count; i++) {
930                 link = kzalloc(sizeof(*link), GFP_KERNEL);
931                 if (!link) {
932                         free_cgrp_cset_links(tmp_links);
933                         return -ENOMEM;
934                 }
935                 list_add(&link->cset_link, tmp_links);
936         }
937         return 0;
938 }
939
940 /**
941  * link_css_set - a helper function to link a css_set to a cgroup
942  * @tmp_links: cgrp_cset_link objects allocated by allocate_cgrp_cset_links()
943  * @cset: the css_set to be linked
944  * @cgrp: the destination cgroup
945  */
946 static void link_css_set(struct list_head *tmp_links, struct css_set *cset,
947                          struct cgroup *cgrp)
948 {
949         struct cgrp_cset_link *link;
950
951         BUG_ON(list_empty(tmp_links));
952
953         if (cgroup_on_dfl(cgrp))
954                 cset->dfl_cgrp = cgrp;
955
956         link = list_first_entry(tmp_links, struct cgrp_cset_link, cset_link);
957         link->cset = cset;
958         link->cgrp = cgrp;
959
960         /*
961          * Always add links to the tail of the lists so that the lists are
962          * in choronological order.
963          */
964         list_move_tail(&link->cset_link, &cgrp->cset_links);
965         list_add_tail(&link->cgrp_link, &cset->cgrp_links);
966
967         if (cgroup_parent(cgrp))
968                 cgroup_get(cgrp);
969 }
970
971 /**
972  * find_css_set - return a new css_set with one cgroup updated
973  * @old_cset: the baseline css_set
974  * @cgrp: the cgroup to be updated
975  *
976  * Return a new css_set that's equivalent to @old_cset, but with @cgrp
977  * substituted into the appropriate hierarchy.
978  */
979 static struct css_set *find_css_set(struct css_set *old_cset,
980                                     struct cgroup *cgrp)
981 {
982         struct cgroup_subsys_state *template[CGROUP_SUBSYS_COUNT] = { };
983         struct css_set *cset;
984         struct list_head tmp_links;
985         struct cgrp_cset_link *link;
986         struct cgroup_subsys *ss;
987         unsigned long key;
988         int ssid;
989
990         lockdep_assert_held(&cgroup_mutex);
991
992         /* First see if we already have a cgroup group that matches
993          * the desired set */
994         spin_lock_bh(&css_set_lock);
995         cset = find_existing_css_set(old_cset, cgrp, template);
996         if (cset)
997                 get_css_set(cset);
998         spin_unlock_bh(&css_set_lock);
999
1000         if (cset)
1001                 return cset;
1002
1003         cset = kzalloc(sizeof(*cset), GFP_KERNEL);
1004         if (!cset)
1005                 return NULL;
1006
1007         /* Allocate all the cgrp_cset_link objects that we'll need */
1008         if (allocate_cgrp_cset_links(cgroup_root_count, &tmp_links) < 0) {
1009                 kfree(cset);
1010                 return NULL;
1011         }
1012
1013         atomic_set(&cset->refcount, 1);
1014         INIT_LIST_HEAD(&cset->cgrp_links);
1015         INIT_LIST_HEAD(&cset->tasks);
1016         INIT_LIST_HEAD(&cset->mg_tasks);
1017         INIT_LIST_HEAD(&cset->mg_preload_node);
1018         INIT_LIST_HEAD(&cset->mg_node);
1019         INIT_LIST_HEAD(&cset->task_iters);
1020         INIT_HLIST_NODE(&cset->hlist);
1021
1022         /* Copy the set of subsystem state objects generated in
1023          * find_existing_css_set() */
1024         memcpy(cset->subsys, template, sizeof(cset->subsys));
1025
1026         spin_lock_bh(&css_set_lock);
1027         /* Add reference counts and links from the new css_set. */
1028         list_for_each_entry(link, &old_cset->cgrp_links, cgrp_link) {
1029                 struct cgroup *c = link->cgrp;
1030
1031                 if (c->root == cgrp->root)
1032                         c = cgrp;
1033                 link_css_set(&tmp_links, cset, c);
1034         }
1035
1036         BUG_ON(!list_empty(&tmp_links));
1037
1038         css_set_count++;
1039
1040         /* Add @cset to the hash table */
1041         key = css_set_hash(cset->subsys);
1042         hash_add(css_set_table, &cset->hlist, key);
1043
1044         for_each_subsys(ss, ssid) {
1045                 struct cgroup_subsys_state *css = cset->subsys[ssid];
1046
1047                 list_add_tail(&cset->e_cset_node[ssid],
1048                               &css->cgroup->e_csets[ssid]);
1049                 css_get(css);
1050         }
1051
1052         spin_unlock_bh(&css_set_lock);
1053
1054         return cset;
1055 }
1056
1057 static struct cgroup_root *cgroup_root_from_kf(struct kernfs_root *kf_root)
1058 {
1059         struct cgroup *root_cgrp = kf_root->kn->priv;
1060
1061         return root_cgrp->root;
1062 }
1063
1064 static int cgroup_init_root_id(struct cgroup_root *root)
1065 {
1066         int id;
1067
1068         lockdep_assert_held(&cgroup_mutex);
1069
1070         id = idr_alloc_cyclic(&cgroup_hierarchy_idr, root, 0, 0, GFP_KERNEL);
1071         if (id < 0)
1072                 return id;
1073
1074         root->hierarchy_id = id;
1075         return 0;
1076 }
1077
1078 static void cgroup_exit_root_id(struct cgroup_root *root)
1079 {
1080         lockdep_assert_held(&cgroup_mutex);
1081
1082         if (root->hierarchy_id) {
1083                 idr_remove(&cgroup_hierarchy_idr, root->hierarchy_id);
1084                 root->hierarchy_id = 0;
1085         }
1086 }
1087
1088 static void cgroup_free_root(struct cgroup_root *root)
1089 {
1090         if (root) {
1091                 /* hierarchy ID should already have been released */
1092                 WARN_ON_ONCE(root->hierarchy_id);
1093
1094                 idr_destroy(&root->cgroup_idr);
1095                 kfree(root);
1096         }
1097 }
1098
1099 static void cgroup_destroy_root(struct cgroup_root *root)
1100 {
1101         struct cgroup *cgrp = &root->cgrp;
1102         struct cgrp_cset_link *link, *tmp_link;
1103
1104         mutex_lock(&cgroup_mutex);
1105
1106         BUG_ON(atomic_read(&root->nr_cgrps));
1107         BUG_ON(!list_empty(&cgrp->self.children));
1108
1109         /* Rebind all subsystems back to the default hierarchy */
1110         rebind_subsystems(&cgrp_dfl_root, root->subsys_mask);
1111
1112         /*
1113          * Release all the links from cset_links to this hierarchy's
1114          * root cgroup
1115          */
1116         spin_lock_bh(&css_set_lock);
1117
1118         list_for_each_entry_safe(link, tmp_link, &cgrp->cset_links, cset_link) {
1119                 list_del(&link->cset_link);
1120                 list_del(&link->cgrp_link);
1121                 kfree(link);
1122         }
1123
1124         spin_unlock_bh(&css_set_lock);
1125
1126         if (!list_empty(&root->root_list)) {
1127                 list_del(&root->root_list);
1128                 cgroup_root_count--;
1129         }
1130
1131         cgroup_exit_root_id(root);
1132
1133         mutex_unlock(&cgroup_mutex);
1134
1135         kernfs_destroy_root(root->kf_root);
1136         cgroup_free_root(root);
1137 }
1138
1139 /* look up cgroup associated with given css_set on the specified hierarchy */
1140 static struct cgroup *cset_cgroup_from_root(struct css_set *cset,
1141                                             struct cgroup_root *root)
1142 {
1143         struct cgroup *res = NULL;
1144
1145         lockdep_assert_held(&cgroup_mutex);
1146         lockdep_assert_held(&css_set_lock);
1147
1148         if (cset == &init_css_set) {
1149                 res = &root->cgrp;
1150         } else {
1151                 struct cgrp_cset_link *link;
1152
1153                 list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
1154                         struct cgroup *c = link->cgrp;
1155
1156                         if (c->root == root) {
1157                                 res = c;
1158                                 break;
1159                         }
1160                 }
1161         }
1162
1163         BUG_ON(!res);
1164         return res;
1165 }
1166
1167 /*
1168  * Return the cgroup for "task" from the given hierarchy. Must be
1169  * called with cgroup_mutex and css_set_lock held.
1170  */
1171 static struct cgroup *task_cgroup_from_root(struct task_struct *task,
1172                                             struct cgroup_root *root)
1173 {
1174         /*
1175          * No need to lock the task - since we hold cgroup_mutex the
1176          * task can't change groups, so the only thing that can happen
1177          * is that it exits and its css is set back to init_css_set.
1178          */
1179         return cset_cgroup_from_root(task_css_set(task), root);
1180 }
1181
1182 /*
1183  * A task must hold cgroup_mutex to modify cgroups.
1184  *
1185  * Any task can increment and decrement the count field without lock.
1186  * So in general, code holding cgroup_mutex can't rely on the count
1187  * field not changing.  However, if the count goes to zero, then only
1188  * cgroup_attach_task() can increment it again.  Because a count of zero
1189  * means that no tasks are currently attached, therefore there is no
1190  * way a task attached to that cgroup can fork (the other way to
1191  * increment the count).  So code holding cgroup_mutex can safely
1192  * assume that if the count is zero, it will stay zero. Similarly, if
1193  * a task holds cgroup_mutex on a cgroup with zero count, it
1194  * knows that the cgroup won't be removed, as cgroup_rmdir()
1195  * needs that mutex.
1196  *
1197  * A cgroup can only be deleted if both its 'count' of using tasks
1198  * is zero, and its list of 'children' cgroups is empty.  Since all
1199  * tasks in the system use _some_ cgroup, and since there is always at
1200  * least one task in the system (init, pid == 1), therefore, root cgroup
1201  * always has either children cgroups and/or using tasks.  So we don't
1202  * need a special hack to ensure that root cgroup cannot be deleted.
1203  *
1204  * P.S.  One more locking exception.  RCU is used to guard the
1205  * update of a tasks cgroup pointer by cgroup_attach_task()
1206  */
1207
1208 static struct kernfs_syscall_ops cgroup_kf_syscall_ops;
1209 static const struct file_operations proc_cgroupstats_operations;
1210
1211 static char *cgroup_file_name(struct cgroup *cgrp, const struct cftype *cft,
1212                               char *buf)
1213 {
1214         struct cgroup_subsys *ss = cft->ss;
1215
1216         if (cft->ss && !(cft->flags & CFTYPE_NO_PREFIX) &&
1217             !(cgrp->root->flags & CGRP_ROOT_NOPREFIX))
1218                 snprintf(buf, CGROUP_FILE_NAME_MAX, "%s.%s",
1219                          cgroup_on_dfl(cgrp) ? ss->name : ss->legacy_name,
1220                          cft->name);
1221         else
1222                 strncpy(buf, cft->name, CGROUP_FILE_NAME_MAX);
1223         return buf;
1224 }
1225
1226 /**
1227  * cgroup_file_mode - deduce file mode of a control file
1228  * @cft: the control file in question
1229  *
1230  * S_IRUGO for read, S_IWUSR for write.
1231  */
1232 static umode_t cgroup_file_mode(const struct cftype *cft)
1233 {
1234         umode_t mode = 0;
1235
1236         if (cft->read_u64 || cft->read_s64 || cft->seq_show)
1237                 mode |= S_IRUGO;
1238
1239         if (cft->write_u64 || cft->write_s64 || cft->write) {
1240                 if (cft->flags & CFTYPE_WORLD_WRITABLE)
1241                         mode |= S_IWUGO;
1242                 else
1243                         mode |= S_IWUSR;
1244         }
1245
1246         return mode;
1247 }
1248
1249 /**
1250  * cgroup_calc_child_subsys_mask - calculate child_subsys_mask
1251  * @cgrp: the target cgroup
1252  * @subtree_control: the new subtree_control mask to consider
1253  *
1254  * On the default hierarchy, a subsystem may request other subsystems to be
1255  * enabled together through its ->depends_on mask.  In such cases, more
1256  * subsystems than specified in "cgroup.subtree_control" may be enabled.
1257  *
1258  * This function calculates which subsystems need to be enabled if
1259  * @subtree_control is to be applied to @cgrp.  The returned mask is always
1260  * a superset of @subtree_control and follows the usual hierarchy rules.
1261  */
1262 static unsigned long cgroup_calc_child_subsys_mask(struct cgroup *cgrp,
1263                                                   unsigned long subtree_control)
1264 {
1265         struct cgroup *parent = cgroup_parent(cgrp);
1266         unsigned long cur_ss_mask = subtree_control;
1267         struct cgroup_subsys *ss;
1268         int ssid;
1269
1270         lockdep_assert_held(&cgroup_mutex);
1271
1272         if (!cgroup_on_dfl(cgrp))
1273                 return cur_ss_mask;
1274
1275         while (true) {
1276                 unsigned long new_ss_mask = cur_ss_mask;
1277
1278                 for_each_subsys_which(ss, ssid, &cur_ss_mask)
1279                         new_ss_mask |= ss->depends_on;
1280
1281                 /*
1282                  * Mask out subsystems which aren't available.  This can
1283                  * happen only if some depended-upon subsystems were bound
1284                  * to non-default hierarchies.
1285                  */
1286                 if (parent)
1287                         new_ss_mask &= parent->child_subsys_mask;
1288                 else
1289                         new_ss_mask &= cgrp->root->subsys_mask;
1290
1291                 if (new_ss_mask == cur_ss_mask)
1292                         break;
1293                 cur_ss_mask = new_ss_mask;
1294         }
1295
1296         return cur_ss_mask;
1297 }
1298
1299 /**
1300  * cgroup_refresh_child_subsys_mask - update child_subsys_mask
1301  * @cgrp: the target cgroup
1302  *
1303  * Update @cgrp->child_subsys_mask according to the current
1304  * @cgrp->subtree_control using cgroup_calc_child_subsys_mask().
1305  */
1306 static void cgroup_refresh_child_subsys_mask(struct cgroup *cgrp)
1307 {
1308         cgrp->child_subsys_mask =
1309                 cgroup_calc_child_subsys_mask(cgrp, cgrp->subtree_control);
1310 }
1311
1312 /**
1313  * cgroup_kn_unlock - unlocking helper for cgroup kernfs methods
1314  * @kn: the kernfs_node being serviced
1315  *
1316  * This helper undoes cgroup_kn_lock_live() and should be invoked before
1317  * the method finishes if locking succeeded.  Note that once this function
1318  * returns the cgroup returned by cgroup_kn_lock_live() may become
1319  * inaccessible any time.  If the caller intends to continue to access the
1320  * cgroup, it should pin it before invoking this function.
1321  */
1322 static void cgroup_kn_unlock(struct kernfs_node *kn)
1323 {
1324         struct cgroup *cgrp;
1325
1326         if (kernfs_type(kn) == KERNFS_DIR)
1327                 cgrp = kn->priv;
1328         else
1329                 cgrp = kn->parent->priv;
1330
1331         mutex_unlock(&cgroup_mutex);
1332
1333         kernfs_unbreak_active_protection(kn);
1334         cgroup_put(cgrp);
1335 }
1336
1337 /**
1338  * cgroup_kn_lock_live - locking helper for cgroup kernfs methods
1339  * @kn: the kernfs_node being serviced
1340  *
1341  * This helper is to be used by a cgroup kernfs method currently servicing
1342  * @kn.  It breaks the active protection, performs cgroup locking and
1343  * verifies that the associated cgroup is alive.  Returns the cgroup if
1344  * alive; otherwise, %NULL.  A successful return should be undone by a
1345  * matching cgroup_kn_unlock() invocation.
1346  *
1347  * Any cgroup kernfs method implementation which requires locking the
1348  * associated cgroup should use this helper.  It avoids nesting cgroup
1349  * locking under kernfs active protection and allows all kernfs operations
1350  * including self-removal.
1351  */
1352 static struct cgroup *cgroup_kn_lock_live(struct kernfs_node *kn)
1353 {
1354         struct cgroup *cgrp;
1355
1356         if (kernfs_type(kn) == KERNFS_DIR)
1357                 cgrp = kn->priv;
1358         else
1359                 cgrp = kn->parent->priv;
1360
1361         /*
1362          * We're gonna grab cgroup_mutex which nests outside kernfs
1363          * active_ref.  cgroup liveliness check alone provides enough
1364          * protection against removal.  Ensure @cgrp stays accessible and
1365          * break the active_ref protection.
1366          */
1367         if (!cgroup_tryget(cgrp))
1368                 return NULL;
1369         kernfs_break_active_protection(kn);
1370
1371         mutex_lock(&cgroup_mutex);
1372
1373         if (!cgroup_is_dead(cgrp))
1374                 return cgrp;
1375
1376         cgroup_kn_unlock(kn);
1377         return NULL;
1378 }
1379
1380 static void cgroup_rm_file(struct cgroup *cgrp, const struct cftype *cft)
1381 {
1382         char name[CGROUP_FILE_NAME_MAX];
1383
1384         lockdep_assert_held(&cgroup_mutex);
1385
1386         if (cft->file_offset) {
1387                 struct cgroup_subsys_state *css = cgroup_css(cgrp, cft->ss);
1388                 struct cgroup_file *cfile = (void *)css + cft->file_offset;
1389
1390                 spin_lock_irq(&cgroup_file_kn_lock);
1391                 cfile->kn = NULL;
1392                 spin_unlock_irq(&cgroup_file_kn_lock);
1393         }
1394
1395         kernfs_remove_by_name(cgrp->kn, cgroup_file_name(cgrp, cft, name));
1396 }
1397
1398 /**
1399  * css_clear_dir - remove subsys files in a cgroup directory
1400  * @css: taget css
1401  * @cgrp_override: specify if target cgroup is different from css->cgroup
1402  */
1403 static void css_clear_dir(struct cgroup_subsys_state *css,
1404                           struct cgroup *cgrp_override)
1405 {
1406         struct cgroup *cgrp = cgrp_override ?: css->cgroup;
1407         struct cftype *cfts;
1408
1409         list_for_each_entry(cfts, &css->ss->cfts, node)
1410                 cgroup_addrm_files(css, cgrp, cfts, false);
1411 }
1412
1413 /**
1414  * css_populate_dir - create subsys files in a cgroup directory
1415  * @css: target css
1416  * @cgrp_overried: specify if target cgroup is different from css->cgroup
1417  *
1418  * On failure, no file is added.
1419  */
1420 static int css_populate_dir(struct cgroup_subsys_state *css,
1421                             struct cgroup *cgrp_override)
1422 {
1423         struct cgroup *cgrp = cgrp_override ?: css->cgroup;
1424         struct cftype *cfts, *failed_cfts;
1425         int ret;
1426
1427         if (!css->ss) {
1428                 if (cgroup_on_dfl(cgrp))
1429                         cfts = cgroup_dfl_base_files;
1430                 else
1431                         cfts = cgroup_legacy_base_files;
1432
1433                 return cgroup_addrm_files(&cgrp->self, cgrp, cfts, true);
1434         }
1435
1436         list_for_each_entry(cfts, &css->ss->cfts, node) {
1437                 ret = cgroup_addrm_files(css, cgrp, cfts, true);
1438                 if (ret < 0) {
1439                         failed_cfts = cfts;
1440                         goto err;
1441                 }
1442         }
1443         return 0;
1444 err:
1445         list_for_each_entry(cfts, &css->ss->cfts, node) {
1446                 if (cfts == failed_cfts)
1447                         break;
1448                 cgroup_addrm_files(css, cgrp, cfts, false);
1449         }
1450         return ret;
1451 }
1452
1453 static int rebind_subsystems(struct cgroup_root *dst_root,
1454                              unsigned long ss_mask)
1455 {
1456         struct cgroup *dcgrp = &dst_root->cgrp;
1457         struct cgroup_subsys *ss;
1458         unsigned long tmp_ss_mask;
1459         int ssid, i, ret;
1460
1461         lockdep_assert_held(&cgroup_mutex);
1462
1463         for_each_subsys_which(ss, ssid, &ss_mask) {
1464                 /* if @ss has non-root csses attached to it, can't move */
1465                 if (css_next_child(NULL, cgroup_css(&ss->root->cgrp, ss)))
1466                         return -EBUSY;
1467
1468                 /* can't move between two non-dummy roots either */
1469                 if (ss->root != &cgrp_dfl_root && dst_root != &cgrp_dfl_root)
1470                         return -EBUSY;
1471         }
1472
1473         /* skip creating root files on dfl_root for inhibited subsystems */
1474         tmp_ss_mask = ss_mask;
1475         if (dst_root == &cgrp_dfl_root)
1476                 tmp_ss_mask &= ~cgrp_dfl_root_inhibit_ss_mask;
1477
1478         for_each_subsys_which(ss, ssid, &tmp_ss_mask) {
1479                 struct cgroup *scgrp = &ss->root->cgrp;
1480                 int tssid;
1481
1482                 ret = css_populate_dir(cgroup_css(scgrp, ss), dcgrp);
1483                 if (!ret)
1484                         continue;
1485
1486                 /*
1487                  * Rebinding back to the default root is not allowed to
1488                  * fail.  Using both default and non-default roots should
1489                  * be rare.  Moving subsystems back and forth even more so.
1490                  * Just warn about it and continue.
1491                  */
1492                 if (dst_root == &cgrp_dfl_root) {
1493                         if (cgrp_dfl_root_visible) {
1494                                 pr_warn("failed to create files (%d) while rebinding 0x%lx to default root\n",
1495                                         ret, ss_mask);
1496                                 pr_warn("you may retry by moving them to a different hierarchy and unbinding\n");
1497                         }
1498                         continue;
1499                 }
1500
1501                 for_each_subsys_which(ss, tssid, &tmp_ss_mask) {
1502                         if (tssid == ssid)
1503                                 break;
1504                         css_clear_dir(cgroup_css(scgrp, ss), dcgrp);
1505                 }
1506                 return ret;
1507         }
1508
1509         /*
1510          * Nothing can fail from this point on.  Remove files for the
1511          * removed subsystems and rebind each subsystem.
1512          */
1513         for_each_subsys_which(ss, ssid, &ss_mask) {
1514                 struct cgroup_root *src_root = ss->root;
1515                 struct cgroup *scgrp = &src_root->cgrp;
1516                 struct cgroup_subsys_state *css = cgroup_css(scgrp, ss);
1517                 struct css_set *cset;
1518
1519                 WARN_ON(!css || cgroup_css(dcgrp, ss));
1520
1521                 css_clear_dir(css, NULL);
1522
1523                 RCU_INIT_POINTER(scgrp->subsys[ssid], NULL);
1524                 rcu_assign_pointer(dcgrp->subsys[ssid], css);
1525                 ss->root = dst_root;
1526                 css->cgroup = dcgrp;
1527
1528                 spin_lock_bh(&css_set_lock);
1529                 hash_for_each(css_set_table, i, cset, hlist)
1530                         list_move_tail(&cset->e_cset_node[ss->id],
1531                                        &dcgrp->e_csets[ss->id]);
1532                 spin_unlock_bh(&css_set_lock);
1533
1534                 src_root->subsys_mask &= ~(1 << ssid);
1535                 scgrp->subtree_control &= ~(1 << ssid);
1536                 cgroup_refresh_child_subsys_mask(scgrp);
1537
1538                 /* default hierarchy doesn't enable controllers by default */
1539                 dst_root->subsys_mask |= 1 << ssid;
1540                 if (dst_root == &cgrp_dfl_root) {
1541                         static_branch_enable(cgroup_subsys_on_dfl_key[ssid]);
1542                 } else {
1543                         dcgrp->subtree_control |= 1 << ssid;
1544                         cgroup_refresh_child_subsys_mask(dcgrp);
1545                         static_branch_disable(cgroup_subsys_on_dfl_key[ssid]);
1546                 }
1547
1548                 if (ss->bind)
1549                         ss->bind(css);
1550         }
1551
1552         kernfs_activate(dcgrp->kn);
1553         return 0;
1554 }
1555
1556 static int cgroup_show_options(struct seq_file *seq,
1557                                struct kernfs_root *kf_root)
1558 {
1559         struct cgroup_root *root = cgroup_root_from_kf(kf_root);
1560         struct cgroup_subsys *ss;
1561         int ssid;
1562
1563         if (root != &cgrp_dfl_root)
1564                 for_each_subsys(ss, ssid)
1565                         if (root->subsys_mask & (1 << ssid))
1566                                 seq_show_option(seq, ss->legacy_name, NULL);
1567         if (root->flags & CGRP_ROOT_NOPREFIX)
1568                 seq_puts(seq, ",noprefix");
1569         if (root->flags & CGRP_ROOT_XATTR)
1570                 seq_puts(seq, ",xattr");
1571
1572         spin_lock(&release_agent_path_lock);
1573         if (strlen(root->release_agent_path))
1574                 seq_show_option(seq, "release_agent",
1575                                 root->release_agent_path);
1576         spin_unlock(&release_agent_path_lock);
1577
1578         if (test_bit(CGRP_CPUSET_CLONE_CHILDREN, &root->cgrp.flags))
1579                 seq_puts(seq, ",clone_children");
1580         if (strlen(root->name))
1581                 seq_show_option(seq, "name", root->name);
1582         return 0;
1583 }
1584
1585 struct cgroup_sb_opts {
1586         unsigned long subsys_mask;
1587         unsigned int flags;
1588         char *release_agent;
1589         bool cpuset_clone_children;
1590         char *name;
1591         /* User explicitly requested empty subsystem */
1592         bool none;
1593 };
1594
1595 static int parse_cgroupfs_options(char *data, struct cgroup_sb_opts *opts)
1596 {
1597         char *token, *o = data;
1598         bool all_ss = false, one_ss = false;
1599         unsigned long mask = -1UL;
1600         struct cgroup_subsys *ss;
1601         int nr_opts = 0;
1602         int i;
1603
1604 #ifdef CONFIG_CPUSETS
1605         mask = ~(1U << cpuset_cgrp_id);
1606 #endif
1607
1608         memset(opts, 0, sizeof(*opts));
1609
1610         while ((token = strsep(&o, ",")) != NULL) {
1611                 nr_opts++;
1612
1613                 if (!*token)
1614                         return -EINVAL;
1615                 if (!strcmp(token, "none")) {
1616                         /* Explicitly have no subsystems */
1617                         opts->none = true;
1618                         continue;
1619                 }
1620                 if (!strcmp(token, "all")) {
1621                         /* Mutually exclusive option 'all' + subsystem name */
1622                         if (one_ss)
1623                                 return -EINVAL;
1624                         all_ss = true;
1625                         continue;
1626                 }
1627                 if (!strcmp(token, "noprefix")) {
1628                         opts->flags |= CGRP_ROOT_NOPREFIX;
1629                         continue;
1630                 }
1631                 if (!strcmp(token, "clone_children")) {
1632                         opts->cpuset_clone_children = true;
1633                         continue;
1634                 }
1635                 if (!strcmp(token, "xattr")) {
1636                         opts->flags |= CGRP_ROOT_XATTR;
1637                         continue;
1638                 }
1639                 if (!strncmp(token, "release_agent=", 14)) {
1640                         /* Specifying two release agents is forbidden */
1641                         if (opts->release_agent)
1642                                 return -EINVAL;
1643                         opts->release_agent =
1644                                 kstrndup(token + 14, PATH_MAX - 1, GFP_KERNEL);
1645                         if (!opts->release_agent)
1646                                 return -ENOMEM;
1647                         continue;
1648                 }
1649                 if (!strncmp(token, "name=", 5)) {
1650                         const char *name = token + 5;
1651                         /* Can't specify an empty name */
1652                         if (!strlen(name))
1653                                 return -EINVAL;
1654                         /* Must match [\w.-]+ */
1655                         for (i = 0; i < strlen(name); i++) {
1656                                 char c = name[i];
1657                                 if (isalnum(c))
1658                                         continue;
1659                                 if ((c == '.') || (c == '-') || (c == '_'))
1660                                         continue;
1661                                 return -EINVAL;
1662                         }
1663                         /* Specifying two names is forbidden */
1664                         if (opts->name)
1665                                 return -EINVAL;
1666                         opts->name = kstrndup(name,
1667                                               MAX_CGROUP_ROOT_NAMELEN - 1,
1668                                               GFP_KERNEL);
1669                         if (!opts->name)
1670                                 return -ENOMEM;
1671
1672                         continue;
1673                 }
1674
1675                 for_each_subsys(ss, i) {
1676                         if (strcmp(token, ss->legacy_name))
1677                                 continue;
1678                         if (!cgroup_ssid_enabled(i))
1679                                 continue;
1680
1681                         /* Mutually exclusive option 'all' + subsystem name */
1682                         if (all_ss)
1683                                 return -EINVAL;
1684                         opts->subsys_mask |= (1 << i);
1685                         one_ss = true;
1686
1687                         break;
1688                 }
1689                 if (i == CGROUP_SUBSYS_COUNT)
1690                         return -ENOENT;
1691         }
1692
1693         /*
1694          * If the 'all' option was specified select all the subsystems,
1695          * otherwise if 'none', 'name=' and a subsystem name options were
1696          * not specified, let's default to 'all'
1697          */
1698         if (all_ss || (!one_ss && !opts->none && !opts->name))
1699                 for_each_subsys(ss, i)
1700                         if (cgroup_ssid_enabled(i))
1701                                 opts->subsys_mask |= (1 << i);
1702
1703         /*
1704          * We either have to specify by name or by subsystems. (So all
1705          * empty hierarchies must have a name).
1706          */
1707         if (!opts->subsys_mask && !opts->name)
1708                 return -EINVAL;
1709
1710         /*
1711          * Option noprefix was introduced just for backward compatibility
1712          * with the old cpuset, so we allow noprefix only if mounting just
1713          * the cpuset subsystem.
1714          */
1715         if ((opts->flags & CGRP_ROOT_NOPREFIX) && (opts->subsys_mask & mask))
1716                 return -EINVAL;
1717
1718         /* Can't specify "none" and some subsystems */
1719         if (opts->subsys_mask && opts->none)
1720                 return -EINVAL;
1721
1722         return 0;
1723 }
1724
1725 static int cgroup_remount(struct kernfs_root *kf_root, int *flags, char *data)
1726 {
1727         int ret = 0;
1728         struct cgroup_root *root = cgroup_root_from_kf(kf_root);
1729         struct cgroup_sb_opts opts;
1730         unsigned long added_mask, removed_mask;
1731
1732         if (root == &cgrp_dfl_root) {
1733                 pr_err("remount is not allowed\n");
1734                 return -EINVAL;
1735         }
1736
1737         mutex_lock(&cgroup_mutex);
1738
1739         /* See what subsystems are wanted */
1740         ret = parse_cgroupfs_options(data, &opts);
1741         if (ret)
1742                 goto out_unlock;
1743
1744         if (opts.subsys_mask != root->subsys_mask || opts.release_agent)
1745                 pr_warn("option changes via remount are deprecated (pid=%d comm=%s)\n",
1746                         task_tgid_nr(current), current->comm);
1747
1748         added_mask = opts.subsys_mask & ~root->subsys_mask;
1749         removed_mask = root->subsys_mask & ~opts.subsys_mask;
1750
1751         /* Don't allow flags or name to change at remount */
1752         if ((opts.flags ^ root->flags) ||
1753             (opts.name && strcmp(opts.name, root->name))) {
1754                 pr_err("option or name mismatch, new: 0x%x \"%s\", old: 0x%x \"%s\"\n",
1755                        opts.flags, opts.name ?: "", root->flags, root->name);
1756                 ret = -EINVAL;
1757                 goto out_unlock;
1758         }
1759
1760         /* remounting is not allowed for populated hierarchies */
1761         if (!list_empty(&root->cgrp.self.children)) {
1762                 ret = -EBUSY;
1763                 goto out_unlock;
1764         }
1765
1766         ret = rebind_subsystems(root, added_mask);
1767         if (ret)
1768                 goto out_unlock;
1769
1770         rebind_subsystems(&cgrp_dfl_root, removed_mask);
1771
1772         if (opts.release_agent) {
1773                 spin_lock(&release_agent_path_lock);
1774                 strcpy(root->release_agent_path, opts.release_agent);
1775                 spin_unlock(&release_agent_path_lock);
1776         }
1777  out_unlock:
1778         kfree(opts.release_agent);
1779         kfree(opts.name);
1780         mutex_unlock(&cgroup_mutex);
1781         return ret;
1782 }
1783
1784 /*
1785  * To reduce the fork() overhead for systems that are not actually using
1786  * their cgroups capability, we don't maintain the lists running through
1787  * each css_set to its tasks until we see the list actually used - in other
1788  * words after the first mount.
1789  */
1790 static bool use_task_css_set_links __read_mostly;
1791
1792 static void cgroup_enable_task_cg_lists(void)
1793 {
1794         struct task_struct *p, *g;
1795
1796         spin_lock_bh(&css_set_lock);
1797
1798         if (use_task_css_set_links)
1799                 goto out_unlock;
1800
1801         use_task_css_set_links = true;
1802
1803         /*
1804          * We need tasklist_lock because RCU is not safe against
1805          * while_each_thread(). Besides, a forking task that has passed
1806          * cgroup_post_fork() without seeing use_task_css_set_links = 1
1807          * is not guaranteed to have its child immediately visible in the
1808          * tasklist if we walk through it with RCU.
1809          */
1810         read_lock(&tasklist_lock);
1811         do_each_thread(g, p) {
1812                 WARN_ON_ONCE(!list_empty(&p->cg_list) ||
1813                              task_css_set(p) != &init_css_set);
1814
1815                 /*
1816                  * We should check if the process is exiting, otherwise
1817                  * it will race with cgroup_exit() in that the list
1818                  * entry won't be deleted though the process has exited.
1819                  * Do it while holding siglock so that we don't end up
1820                  * racing against cgroup_exit().
1821                  */
1822                 spin_lock_irq(&p->sighand->siglock);
1823                 if (!(p->flags & PF_EXITING)) {
1824                         struct css_set *cset = task_css_set(p);
1825
1826                         if (!css_set_populated(cset))
1827                                 css_set_update_populated(cset, true);
1828                         list_add_tail(&p->cg_list, &cset->tasks);
1829                         get_css_set(cset);
1830                 }
1831                 spin_unlock_irq(&p->sighand->siglock);
1832         } while_each_thread(g, p);
1833         read_unlock(&tasklist_lock);
1834 out_unlock:
1835         spin_unlock_bh(&css_set_lock);
1836 }
1837
1838 static void init_cgroup_housekeeping(struct cgroup *cgrp)
1839 {
1840         struct cgroup_subsys *ss;
1841         int ssid;
1842
1843         INIT_LIST_HEAD(&cgrp->self.sibling);
1844         INIT_LIST_HEAD(&cgrp->self.children);
1845         INIT_LIST_HEAD(&cgrp->cset_links);
1846         INIT_LIST_HEAD(&cgrp->pidlists);
1847         mutex_init(&cgrp->pidlist_mutex);
1848         cgrp->self.cgroup = cgrp;
1849         cgrp->self.flags |= CSS_ONLINE;
1850
1851         for_each_subsys(ss, ssid)
1852                 INIT_LIST_HEAD(&cgrp->e_csets[ssid]);
1853
1854         init_waitqueue_head(&cgrp->offline_waitq);
1855         INIT_WORK(&cgrp->release_agent_work, cgroup_release_agent);
1856 }
1857
1858 static void init_cgroup_root(struct cgroup_root *root,
1859                              struct cgroup_sb_opts *opts)
1860 {
1861         struct cgroup *cgrp = &root->cgrp;
1862
1863         INIT_LIST_HEAD(&root->root_list);
1864         atomic_set(&root->nr_cgrps, 1);
1865         cgrp->root = root;
1866         init_cgroup_housekeeping(cgrp);
1867         idr_init(&root->cgroup_idr);
1868
1869         root->flags = opts->flags;
1870         if (opts->release_agent)
1871                 strcpy(root->release_agent_path, opts->release_agent);
1872         if (opts->name)
1873                 strcpy(root->name, opts->name);
1874         if (opts->cpuset_clone_children)
1875                 set_bit(CGRP_CPUSET_CLONE_CHILDREN, &root->cgrp.flags);
1876 }
1877
1878 static int cgroup_setup_root(struct cgroup_root *root, unsigned long ss_mask)
1879 {
1880         LIST_HEAD(tmp_links);
1881         struct cgroup *root_cgrp = &root->cgrp;
1882         struct css_set *cset;
1883         int i, ret;
1884
1885         lockdep_assert_held(&cgroup_mutex);
1886
1887         ret = cgroup_idr_alloc(&root->cgroup_idr, root_cgrp, 1, 2, GFP_KERNEL);
1888         if (ret < 0)
1889                 goto out;
1890         root_cgrp->id = ret;
1891         root_cgrp->ancestor_ids[0] = ret;
1892
1893         ret = percpu_ref_init(&root_cgrp->self.refcnt, css_release, 0,
1894                               GFP_KERNEL);
1895         if (ret)
1896                 goto out;
1897
1898         /*
1899          * We're accessing css_set_count without locking css_set_lock here,
1900          * but that's OK - it can only be increased by someone holding
1901          * cgroup_lock, and that's us. The worst that can happen is that we
1902          * have some link structures left over
1903          */
1904         ret = allocate_cgrp_cset_links(css_set_count, &tmp_links);
1905         if (ret)
1906                 goto cancel_ref;
1907
1908         ret = cgroup_init_root_id(root);
1909         if (ret)
1910                 goto cancel_ref;
1911
1912         root->kf_root = kernfs_create_root(&cgroup_kf_syscall_ops,
1913                                            KERNFS_ROOT_CREATE_DEACTIVATED,
1914                                            root_cgrp);
1915         if (IS_ERR(root->kf_root)) {
1916                 ret = PTR_ERR(root->kf_root);
1917                 goto exit_root_id;
1918         }
1919         root_cgrp->kn = root->kf_root->kn;
1920
1921         ret = css_populate_dir(&root_cgrp->self, NULL);
1922         if (ret)
1923                 goto destroy_root;
1924
1925         ret = rebind_subsystems(root, ss_mask);
1926         if (ret)
1927                 goto destroy_root;
1928
1929         /*
1930          * There must be no failure case after here, since rebinding takes
1931          * care of subsystems' refcounts, which are explicitly dropped in
1932          * the failure exit path.
1933          */
1934         list_add(&root->root_list, &cgroup_roots);
1935         cgroup_root_count++;
1936
1937         /*
1938          * Link the root cgroup in this hierarchy into all the css_set
1939          * objects.
1940          */
1941         spin_lock_bh(&css_set_lock);
1942         hash_for_each(css_set_table, i, cset, hlist) {
1943                 link_css_set(&tmp_links, cset, root_cgrp);
1944                 if (css_set_populated(cset))
1945                         cgroup_update_populated(root_cgrp, true);
1946         }
1947         spin_unlock_bh(&css_set_lock);
1948
1949         BUG_ON(!list_empty(&root_cgrp->self.children));
1950         BUG_ON(atomic_read(&root->nr_cgrps) != 1);
1951
1952         kernfs_activate(root_cgrp->kn);
1953         ret = 0;
1954         goto out;
1955
1956 destroy_root:
1957         kernfs_destroy_root(root->kf_root);
1958         root->kf_root = NULL;
1959 exit_root_id:
1960         cgroup_exit_root_id(root);
1961 cancel_ref:
1962         percpu_ref_exit(&root_cgrp->self.refcnt);
1963 out:
1964         free_cgrp_cset_links(&tmp_links);
1965         return ret;
1966 }
1967
1968 static struct dentry *cgroup_mount(struct file_system_type *fs_type,
1969                          int flags, const char *unused_dev_name,
1970                          void *data)
1971 {
1972         bool is_v2 = fs_type == &cgroup2_fs_type;
1973         struct super_block *pinned_sb = NULL;
1974         struct cgroup_subsys *ss;
1975         struct cgroup_root *root;
1976         struct cgroup_sb_opts opts;
1977         struct dentry *dentry;
1978         int ret;
1979         int i;
1980         bool new_sb;
1981
1982         /*
1983          * The first time anyone tries to mount a cgroup, enable the list
1984          * linking each css_set to its tasks and fix up all existing tasks.
1985          */
1986         if (!use_task_css_set_links)
1987                 cgroup_enable_task_cg_lists();
1988
1989         if (is_v2) {
1990                 if (data) {
1991                         pr_err("cgroup2: unknown option \"%s\"\n", (char *)data);
1992                         return ERR_PTR(-EINVAL);
1993                 }
1994                 cgrp_dfl_root_visible = true;
1995                 root = &cgrp_dfl_root;
1996                 cgroup_get(&root->cgrp);
1997                 goto out_mount;
1998         }
1999
2000         mutex_lock(&cgroup_mutex);
2001
2002         /* First find the desired set of subsystems */
2003         ret = parse_cgroupfs_options(data, &opts);
2004         if (ret)
2005                 goto out_unlock;
2006
2007         /*
2008          * Destruction of cgroup root is asynchronous, so subsystems may
2009          * still be dying after the previous unmount.  Let's drain the
2010          * dying subsystems.  We just need to ensure that the ones
2011          * unmounted previously finish dying and don't care about new ones
2012          * starting.  Testing ref liveliness is good enough.
2013          */
2014         for_each_subsys(ss, i) {
2015                 if (!(opts.subsys_mask & (1 << i)) ||
2016                     ss->root == &cgrp_dfl_root)
2017                         continue;
2018
2019                 if (!percpu_ref_tryget_live(&ss->root->cgrp.self.refcnt)) {
2020                         mutex_unlock(&cgroup_mutex);
2021                         msleep(10);
2022                         ret = restart_syscall();
2023                         goto out_free;
2024                 }
2025                 cgroup_put(&ss->root->cgrp);
2026         }
2027
2028         for_each_root(root) {
2029                 bool name_match = false;
2030
2031                 if (root == &cgrp_dfl_root)
2032                         continue;
2033
2034                 /*
2035                  * If we asked for a name then it must match.  Also, if
2036                  * name matches but sybsys_mask doesn't, we should fail.
2037                  * Remember whether name matched.
2038                  */
2039                 if (opts.name) {
2040                         if (strcmp(opts.name, root->name))
2041                                 continue;
2042                         name_match = true;
2043                 }
2044
2045                 /*
2046                  * If we asked for subsystems (or explicitly for no
2047                  * subsystems) then they must match.
2048                  */
2049                 if ((opts.subsys_mask || opts.none) &&
2050                     (opts.subsys_mask != root->subsys_mask)) {
2051                         if (!name_match)
2052                                 continue;
2053                         ret = -EBUSY;
2054                         goto out_unlock;
2055                 }
2056
2057                 if (root->flags ^ opts.flags)
2058                         pr_warn("new mount options do not match the existing superblock, will be ignored\n");
2059
2060                 /*
2061                  * We want to reuse @root whose lifetime is governed by its
2062                  * ->cgrp.  Let's check whether @root is alive and keep it
2063                  * that way.  As cgroup_kill_sb() can happen anytime, we
2064                  * want to block it by pinning the sb so that @root doesn't
2065                  * get killed before mount is complete.
2066                  *
2067                  * With the sb pinned, tryget_live can reliably indicate
2068                  * whether @root can be reused.  If it's being killed,
2069                  * drain it.  We can use wait_queue for the wait but this
2070                  * path is super cold.  Let's just sleep a bit and retry.
2071                  */
2072                 pinned_sb = kernfs_pin_sb(root->kf_root, NULL);
2073                 if (IS_ERR(pinned_sb) ||
2074                     !percpu_ref_tryget_live(&root->cgrp.self.refcnt)) {
2075                         mutex_unlock(&cgroup_mutex);
2076                         if (!IS_ERR_OR_NULL(pinned_sb))
2077                                 deactivate_super(pinned_sb);
2078                         msleep(10);
2079                         ret = restart_syscall();
2080                         goto out_free;
2081                 }
2082
2083                 ret = 0;
2084                 goto out_unlock;
2085         }
2086
2087         /*
2088          * No such thing, create a new one.  name= matching without subsys
2089          * specification is allowed for already existing hierarchies but we
2090          * can't create new one without subsys specification.
2091          */
2092         if (!opts.subsys_mask && !opts.none) {
2093                 ret = -EINVAL;
2094                 goto out_unlock;
2095         }
2096
2097         root = kzalloc(sizeof(*root), GFP_KERNEL);
2098         if (!root) {
2099                 ret = -ENOMEM;
2100                 goto out_unlock;
2101         }
2102
2103         init_cgroup_root(root, &opts);
2104
2105         ret = cgroup_setup_root(root, opts.subsys_mask);
2106         if (ret)
2107                 cgroup_free_root(root);
2108
2109 out_unlock:
2110         mutex_unlock(&cgroup_mutex);
2111 out_free:
2112         kfree(opts.release_agent);
2113         kfree(opts.name);
2114
2115         if (ret)
2116                 return ERR_PTR(ret);
2117 out_mount:
2118         dentry = kernfs_mount(fs_type, flags, root->kf_root,
2119                               is_v2 ? CGROUP2_SUPER_MAGIC : CGROUP_SUPER_MAGIC,
2120                               &new_sb);
2121         if (IS_ERR(dentry) || !new_sb)
2122                 cgroup_put(&root->cgrp);
2123
2124         /*
2125          * If @pinned_sb, we're reusing an existing root and holding an
2126          * extra ref on its sb.  Mount is complete.  Put the extra ref.
2127          */
2128         if (pinned_sb) {
2129                 WARN_ON(new_sb);
2130                 deactivate_super(pinned_sb);
2131         }
2132
2133         return dentry;
2134 }
2135
2136 static void cgroup_kill_sb(struct super_block *sb)
2137 {
2138         struct kernfs_root *kf_root = kernfs_root_from_sb(sb);
2139         struct cgroup_root *root = cgroup_root_from_kf(kf_root);
2140
2141         /*
2142          * If @root doesn't have any mounts or children, start killing it.
2143          * This prevents new mounts by disabling percpu_ref_tryget_live().
2144          * cgroup_mount() may wait for @root's release.
2145          *
2146          * And don't kill the default root.
2147          */
2148         if (!list_empty(&root->cgrp.self.children) ||
2149             root == &cgrp_dfl_root)
2150                 cgroup_put(&root->cgrp);
2151         else
2152                 percpu_ref_kill(&root->cgrp.self.refcnt);
2153
2154         kernfs_kill_sb(sb);
2155 }
2156
2157 static struct file_system_type cgroup_fs_type = {
2158         .name = "cgroup",
2159         .mount = cgroup_mount,
2160         .kill_sb = cgroup_kill_sb,
2161 };
2162
2163 static struct file_system_type cgroup2_fs_type = {
2164         .name = "cgroup2",
2165         .mount = cgroup_mount,
2166         .kill_sb = cgroup_kill_sb,
2167 };
2168
2169 /**
2170  * task_cgroup_path - cgroup path of a task in the first cgroup hierarchy
2171  * @task: target task
2172  * @buf: the buffer to write the path into
2173  * @buflen: the length of the buffer
2174  *
2175  * Determine @task's cgroup on the first (the one with the lowest non-zero
2176  * hierarchy_id) cgroup hierarchy and copy its path into @buf.  This
2177  * function grabs cgroup_mutex and shouldn't be used inside locks used by
2178  * cgroup controller callbacks.
2179  *
2180  * Return value is the same as kernfs_path().
2181  */
2182 char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen)
2183 {
2184         struct cgroup_root *root;
2185         struct cgroup *cgrp;
2186         int hierarchy_id = 1;
2187         char *path = NULL;
2188
2189         mutex_lock(&cgroup_mutex);
2190         spin_lock_bh(&css_set_lock);
2191
2192         root = idr_get_next(&cgroup_hierarchy_idr, &hierarchy_id);
2193
2194         if (root) {
2195                 cgrp = task_cgroup_from_root(task, root);
2196                 path = cgroup_path(cgrp, buf, buflen);
2197         } else {
2198                 /* if no hierarchy exists, everyone is in "/" */
2199                 if (strlcpy(buf, "/", buflen) < buflen)
2200                         path = buf;
2201         }
2202
2203         spin_unlock_bh(&css_set_lock);
2204         mutex_unlock(&cgroup_mutex);
2205         return path;
2206 }
2207 EXPORT_SYMBOL_GPL(task_cgroup_path);
2208
2209 /* used to track tasks and other necessary states during migration */
2210 struct cgroup_taskset {
2211         /* the src and dst cset list running through cset->mg_node */
2212         struct list_head        src_csets;
2213         struct list_head        dst_csets;
2214
2215         /* the subsys currently being processed */
2216         int                     ssid;
2217
2218         /*
2219          * Fields for cgroup_taskset_*() iteration.
2220          *
2221          * Before migration is committed, the target migration tasks are on
2222          * ->mg_tasks of the csets on ->src_csets.  After, on ->mg_tasks of
2223          * the csets on ->dst_csets.  ->csets point to either ->src_csets
2224          * or ->dst_csets depending on whether migration is committed.
2225          *
2226          * ->cur_csets and ->cur_task point to the current task position
2227          * during iteration.
2228          */
2229         struct list_head        *csets;
2230         struct css_set          *cur_cset;
2231         struct task_struct      *cur_task;
2232 };
2233
2234 #define CGROUP_TASKSET_INIT(tset)       (struct cgroup_taskset){        \
2235         .src_csets              = LIST_HEAD_INIT(tset.src_csets),       \
2236         .dst_csets              = LIST_HEAD_INIT(tset.dst_csets),       \
2237         .csets                  = &tset.src_csets,                      \
2238 }
2239
2240 /**
2241  * cgroup_taskset_add - try to add a migration target task to a taskset
2242  * @task: target task
2243  * @tset: target taskset
2244  *
2245  * Add @task, which is a migration target, to @tset.  This function becomes
2246  * noop if @task doesn't need to be migrated.  @task's css_set should have
2247  * been added as a migration source and @task->cg_list will be moved from
2248  * the css_set's tasks list to mg_tasks one.
2249  */
2250 static void cgroup_taskset_add(struct task_struct *task,
2251                                struct cgroup_taskset *tset)
2252 {
2253         struct css_set *cset;
2254
2255         lockdep_assert_held(&css_set_lock);
2256
2257         /* @task either already exited or can't exit until the end */
2258         if (task->flags & PF_EXITING)
2259                 return;
2260
2261         /* leave @task alone if post_fork() hasn't linked it yet */
2262         if (list_empty(&task->cg_list))
2263                 return;
2264
2265         cset = task_css_set(task);
2266         if (!cset->mg_src_cgrp)
2267                 return;
2268
2269         list_move_tail(&task->cg_list, &cset->mg_tasks);
2270         if (list_empty(&cset->mg_node))
2271                 list_add_tail(&cset->mg_node, &tset->src_csets);
2272         if (list_empty(&cset->mg_dst_cset->mg_node))
2273                 list_move_tail(&cset->mg_dst_cset->mg_node,
2274                                &tset->dst_csets);
2275 }
2276
2277 /**
2278  * cgroup_taskset_first - reset taskset and return the first task
2279  * @tset: taskset of interest
2280  * @dst_cssp: output variable for the destination css
2281  *
2282  * @tset iteration is initialized and the first task is returned.
2283  */
2284 struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset,
2285                                          struct cgroup_subsys_state **dst_cssp)
2286 {
2287         tset->cur_cset = list_first_entry(tset->csets, struct css_set, mg_node);
2288         tset->cur_task = NULL;
2289
2290         return cgroup_taskset_next(tset, dst_cssp);
2291 }
2292
2293 /**
2294  * cgroup_taskset_next - iterate to the next task in taskset
2295  * @tset: taskset of interest
2296  * @dst_cssp: output variable for the destination css
2297  *
2298  * Return the next task in @tset.  Iteration must have been initialized
2299  * with cgroup_taskset_first().
2300  */
2301 struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset,
2302                                         struct cgroup_subsys_state **dst_cssp)
2303 {
2304         struct css_set *cset = tset->cur_cset;
2305         struct task_struct *task = tset->cur_task;
2306
2307         while (&cset->mg_node != tset->csets) {
2308                 if (!task)
2309                         task = list_first_entry(&cset->mg_tasks,
2310                                                 struct task_struct, cg_list);
2311                 else
2312                         task = list_next_entry(task, cg_list);
2313
2314                 if (&task->cg_list != &cset->mg_tasks) {
2315                         tset->cur_cset = cset;
2316                         tset->cur_task = task;
2317
2318                         /*
2319                          * This function may be called both before and
2320                          * after cgroup_taskset_migrate().  The two cases
2321                          * can be distinguished by looking at whether @cset
2322                          * has its ->mg_dst_cset set.
2323                          */
2324                         if (cset->mg_dst_cset)
2325                                 *dst_cssp = cset->mg_dst_cset->subsys[tset->ssid];
2326                         else
2327                                 *dst_cssp = cset->subsys[tset->ssid];
2328
2329                         return task;
2330                 }
2331
2332                 cset = list_next_entry(cset, mg_node);
2333                 task = NULL;
2334         }
2335
2336         return NULL;
2337 }
2338
2339 /**
2340  * cgroup_taskset_migrate - migrate a taskset to a cgroup
2341  * @tset: taget taskset
2342  * @dst_cgrp: destination cgroup
2343  *
2344  * Migrate tasks in @tset to @dst_cgrp.  This function fails iff one of the
2345  * ->can_attach callbacks fails and guarantees that either all or none of
2346  * the tasks in @tset are migrated.  @tset is consumed regardless of
2347  * success.
2348  */
2349 static int cgroup_taskset_migrate(struct cgroup_taskset *tset,
2350                                   struct cgroup *dst_cgrp)
2351 {
2352         struct cgroup_subsys_state *css, *failed_css = NULL;
2353         struct task_struct *task, *tmp_task;
2354         struct css_set *cset, *tmp_cset;
2355         int i, ret;
2356
2357         /* methods shouldn't be called if no task is actually migrating */
2358         if (list_empty(&tset->src_csets))
2359                 return 0;
2360
2361         /* check that we can legitimately attach to the cgroup */
2362         for_each_e_css(css, i, dst_cgrp) {
2363                 if (css->ss->can_attach) {
2364                         tset->ssid = i;
2365                         ret = css->ss->can_attach(tset);
2366                         if (ret) {
2367                                 failed_css = css;
2368                                 goto out_cancel_attach;
2369                         }
2370                 }
2371         }
2372
2373         /*
2374          * Now that we're guaranteed success, proceed to move all tasks to
2375          * the new cgroup.  There are no failure cases after here, so this
2376          * is the commit point.
2377          */
2378         spin_lock_bh(&css_set_lock);
2379         list_for_each_entry(cset, &tset->src_csets, mg_node) {
2380                 list_for_each_entry_safe(task, tmp_task, &cset->mg_tasks, cg_list) {
2381                         struct css_set *from_cset = task_css_set(task);
2382                         struct css_set *to_cset = cset->mg_dst_cset;
2383
2384                         get_css_set(to_cset);
2385                         css_set_move_task(task, from_cset, to_cset, true);
2386                         put_css_set_locked(from_cset);
2387                 }
2388         }
2389         spin_unlock_bh(&css_set_lock);
2390
2391         /*
2392          * Migration is committed, all target tasks are now on dst_csets.
2393          * Nothing is sensitive to fork() after this point.  Notify
2394          * controllers that migration is complete.
2395          */
2396         tset->csets = &tset->dst_csets;
2397
2398         for_each_e_css(css, i, dst_cgrp) {
2399                 if (css->ss->attach) {
2400                         tset->ssid = i;
2401                         css->ss->attach(tset);
2402                 }
2403         }
2404
2405         ret = 0;
2406         goto out_release_tset;
2407
2408 out_cancel_attach:
2409         for_each_e_css(css, i, dst_cgrp) {
2410                 if (css == failed_css)
2411                         break;
2412                 if (css->ss->cancel_attach) {
2413                         tset->ssid = i;
2414                         css->ss->cancel_attach(tset);
2415                 }
2416         }
2417 out_release_tset:
2418         spin_lock_bh(&css_set_lock);
2419         list_splice_init(&tset->dst_csets, &tset->src_csets);
2420         list_for_each_entry_safe(cset, tmp_cset, &tset->src_csets, mg_node) {
2421                 list_splice_tail_init(&cset->mg_tasks, &cset->tasks);
2422                 list_del_init(&cset->mg_node);
2423         }
2424         spin_unlock_bh(&css_set_lock);
2425         return ret;
2426 }
2427
2428 /**
2429  * cgroup_migrate_finish - cleanup after attach
2430  * @preloaded_csets: list of preloaded css_sets
2431  *
2432  * Undo cgroup_migrate_add_src() and cgroup_migrate_prepare_dst().  See
2433  * those functions for details.
2434  */
2435 static void cgroup_migrate_finish(struct list_head *preloaded_csets)
2436 {
2437         struct css_set *cset, *tmp_cset;
2438
2439         lockdep_assert_held(&cgroup_mutex);
2440
2441         spin_lock_bh(&css_set_lock);
2442         list_for_each_entry_safe(cset, tmp_cset, preloaded_csets, mg_preload_node) {
2443                 cset->mg_src_cgrp = NULL;
2444                 cset->mg_dst_cset = NULL;
2445                 list_del_init(&cset->mg_preload_node);
2446                 put_css_set_locked(cset);
2447         }
2448         spin_unlock_bh(&css_set_lock);
2449 }
2450
2451 /**
2452  * cgroup_migrate_add_src - add a migration source css_set
2453  * @src_cset: the source css_set to add
2454  * @dst_cgrp: the destination cgroup
2455  * @preloaded_csets: list of preloaded css_sets
2456  *
2457  * Tasks belonging to @src_cset are about to be migrated to @dst_cgrp.  Pin
2458  * @src_cset and add it to @preloaded_csets, which should later be cleaned
2459  * up by cgroup_migrate_finish().
2460  *
2461  * This function may be called without holding cgroup_threadgroup_rwsem
2462  * even if the target is a process.  Threads may be created and destroyed
2463  * but as long as cgroup_mutex is not dropped, no new css_set can be put
2464  * into play and the preloaded css_sets are guaranteed to cover all
2465  * migrations.
2466  */
2467 static void cgroup_migrate_add_src(struct css_set *src_cset,
2468                                    struct cgroup *dst_cgrp,
2469                                    struct list_head *preloaded_csets)
2470 {
2471         struct cgroup *src_cgrp;
2472
2473         lockdep_assert_held(&cgroup_mutex);
2474         lockdep_assert_held(&css_set_lock);
2475
2476         src_cgrp = cset_cgroup_from_root(src_cset, dst_cgrp->root);
2477
2478         if (!list_empty(&src_cset->mg_preload_node))
2479                 return;
2480
2481         WARN_ON(src_cset->mg_src_cgrp);
2482         WARN_ON(!list_empty(&src_cset->mg_tasks));
2483         WARN_ON(!list_empty(&src_cset->mg_node));
2484
2485         src_cset->mg_src_cgrp = src_cgrp;
2486         get_css_set(src_cset);
2487         list_add(&src_cset->mg_preload_node, preloaded_csets);
2488 }
2489
2490 /**
2491  * cgroup_migrate_prepare_dst - prepare destination css_sets for migration
2492  * @dst_cgrp: the destination cgroup (may be %NULL)
2493  * @preloaded_csets: list of preloaded source css_sets
2494  *
2495  * Tasks are about to be moved to @dst_cgrp and all the source css_sets
2496  * have been preloaded to @preloaded_csets.  This function looks up and
2497  * pins all destination css_sets, links each to its source, and append them
2498  * to @preloaded_csets.  If @dst_cgrp is %NULL, the destination of each
2499  * source css_set is assumed to be its cgroup on the default hierarchy.
2500  *
2501  * This function must be called after cgroup_migrate_add_src() has been
2502  * called on each migration source css_set.  After migration is performed
2503  * using cgroup_migrate(), cgroup_migrate_finish() must be called on
2504  * @preloaded_csets.
2505  */
2506 static int cgroup_migrate_prepare_dst(struct cgroup *dst_cgrp,
2507                                       struct list_head *preloaded_csets)
2508 {
2509         LIST_HEAD(csets);
2510         struct css_set *src_cset, *tmp_cset;
2511
2512         lockdep_assert_held(&cgroup_mutex);
2513
2514         /*
2515          * Except for the root, child_subsys_mask must be zero for a cgroup
2516          * with tasks so that child cgroups don't compete against tasks.
2517          */
2518         if (dst_cgrp && cgroup_on_dfl(dst_cgrp) && cgroup_parent(dst_cgrp) &&
2519             dst_cgrp->child_subsys_mask)
2520                 return -EBUSY;
2521
2522         /* look up the dst cset for each src cset and link it to src */
2523         list_for_each_entry_safe(src_cset, tmp_cset, preloaded_csets, mg_preload_node) {
2524                 struct css_set *dst_cset;
2525
2526                 dst_cset = find_css_set(src_cset,
2527                                         dst_cgrp ?: src_cset->dfl_cgrp);
2528                 if (!dst_cset)
2529                         goto err;
2530
2531                 WARN_ON_ONCE(src_cset->mg_dst_cset || dst_cset->mg_dst_cset);
2532
2533                 /*
2534                  * If src cset equals dst, it's noop.  Drop the src.
2535                  * cgroup_migrate() will skip the cset too.  Note that we
2536                  * can't handle src == dst as some nodes are used by both.
2537                  */
2538                 if (src_cset == dst_cset) {
2539                         src_cset->mg_src_cgrp = NULL;
2540                         list_del_init(&src_cset->mg_preload_node);
2541                         put_css_set(src_cset);
2542                         put_css_set(dst_cset);
2543                         continue;
2544                 }
2545
2546                 src_cset->mg_dst_cset = dst_cset;
2547
2548                 if (list_empty(&dst_cset->mg_preload_node))
2549                         list_add(&dst_cset->mg_preload_node, &csets);
2550                 else
2551                         put_css_set(dst_cset);
2552         }
2553
2554         list_splice_tail(&csets, preloaded_csets);
2555         return 0;
2556 err:
2557         cgroup_migrate_finish(&csets);
2558         return -ENOMEM;
2559 }
2560
2561 /**
2562  * cgroup_migrate - migrate a process or task to a cgroup
2563  * @leader: the leader of the process or the task to migrate
2564  * @threadgroup: whether @leader points to the whole process or a single task
2565  * @cgrp: the destination cgroup
2566  *
2567  * Migrate a process or task denoted by @leader to @cgrp.  If migrating a
2568  * process, the caller must be holding cgroup_threadgroup_rwsem.  The
2569  * caller is also responsible for invoking cgroup_migrate_add_src() and
2570  * cgroup_migrate_prepare_dst() on the targets before invoking this
2571  * function and following up with cgroup_migrate_finish().
2572  *
2573  * As long as a controller's ->can_attach() doesn't fail, this function is
2574  * guaranteed to succeed.  This means that, excluding ->can_attach()
2575  * failure, when migrating multiple targets, the success or failure can be
2576  * decided for all targets by invoking group_migrate_prepare_dst() before
2577  * actually starting migrating.
2578  */
2579 static int cgroup_migrate(struct task_struct *leader, bool threadgroup,
2580                           struct cgroup *cgrp)
2581 {
2582         struct cgroup_taskset tset = CGROUP_TASKSET_INIT(tset);
2583         struct task_struct *task;
2584
2585         /*
2586          * Prevent freeing of tasks while we take a snapshot. Tasks that are
2587          * already PF_EXITING could be freed from underneath us unless we
2588          * take an rcu_read_lock.
2589          */
2590         spin_lock_bh(&css_set_lock);
2591         rcu_read_lock();
2592         task = leader;
2593         do {
2594                 cgroup_taskset_add(task, &tset);
2595                 if (!threadgroup)
2596                         break;
2597         } while_each_thread(leader, task);
2598         rcu_read_unlock();
2599         spin_unlock_bh(&css_set_lock);
2600
2601         return cgroup_taskset_migrate(&tset, cgrp);
2602 }
2603
2604 /**
2605  * cgroup_attach_task - attach a task or a whole threadgroup to a cgroup
2606  * @dst_cgrp: the cgroup to attach to
2607  * @leader: the task or the leader of the threadgroup to be attached
2608  * @threadgroup: attach the whole threadgroup?
2609  *
2610  * Call holding cgroup_mutex and cgroup_threadgroup_rwsem.
2611  */
2612 static int cgroup_attach_task(struct cgroup *dst_cgrp,
2613                               struct task_struct *leader, bool threadgroup)
2614 {
2615         LIST_HEAD(preloaded_csets);
2616         struct task_struct *task;
2617         int ret;
2618
2619         /* look up all src csets */
2620         spin_lock_bh(&css_set_lock);
2621         rcu_read_lock();
2622         task = leader;
2623         do {
2624                 cgroup_migrate_add_src(task_css_set(task), dst_cgrp,
2625                                        &preloaded_csets);
2626                 if (!threadgroup)
2627                         break;
2628         } while_each_thread(leader, task);
2629         rcu_read_unlock();
2630         spin_unlock_bh(&css_set_lock);
2631
2632         /* prepare dst csets and commit */
2633         ret = cgroup_migrate_prepare_dst(dst_cgrp, &preloaded_csets);
2634         if (!ret)
2635                 ret = cgroup_migrate(leader, threadgroup, dst_cgrp);
2636
2637         cgroup_migrate_finish(&preloaded_csets);
2638         return ret;
2639 }
2640
2641 static int cgroup_procs_write_permission(struct task_struct *task,
2642                                          struct cgroup *dst_cgrp,
2643                                          struct kernfs_open_file *of)
2644 {
2645         const struct cred *cred = current_cred();
2646         const struct cred *tcred = get_task_cred(task);
2647         int ret = 0;
2648
2649         /*
2650          * even if we're attaching all tasks in the thread group, we only
2651          * need to check permissions on one of them.
2652          */
2653         if (!uid_eq(cred->euid, GLOBAL_ROOT_UID) &&
2654             !uid_eq(cred->euid, tcred->uid) &&
2655             !uid_eq(cred->euid, tcred->suid))
2656                 ret = -EACCES;
2657
2658         if (!ret && cgroup_on_dfl(dst_cgrp)) {
2659                 struct super_block *sb = of->file->f_path.dentry->d_sb;
2660                 struct cgroup *cgrp;
2661                 struct inode *inode;
2662
2663                 spin_lock_bh(&css_set_lock);
2664                 cgrp = task_cgroup_from_root(task, &cgrp_dfl_root);
2665                 spin_unlock_bh(&css_set_lock);
2666
2667                 while (!cgroup_is_descendant(dst_cgrp, cgrp))
2668                         cgrp = cgroup_parent(cgrp);
2669
2670                 ret = -ENOMEM;
2671                 inode = kernfs_get_inode(sb, cgrp->procs_file.kn);
2672                 if (inode) {
2673                         ret = inode_permission(inode, MAY_WRITE);
2674                         iput(inode);
2675                 }
2676         }
2677
2678         put_cred(tcred);
2679         return ret;
2680 }
2681
2682 /*
2683  * Find the task_struct of the task to attach by vpid and pass it along to the
2684  * function to attach either it or all tasks in its threadgroup. Will lock
2685  * cgroup_mutex and threadgroup.
2686  */
2687 static ssize_t __cgroup_procs_write(struct kernfs_open_file *of, char *buf,
2688                                     size_t nbytes, loff_t off, bool threadgroup)
2689 {
2690         struct task_struct *tsk;
2691         struct cgroup *cgrp;
2692         pid_t pid;
2693         int ret;
2694
2695         if (kstrtoint(strstrip(buf), 0, &pid) || pid < 0)
2696                 return -EINVAL;
2697
2698         cgrp = cgroup_kn_lock_live(of->kn);
2699         if (!cgrp)
2700                 return -ENODEV;
2701
2702         percpu_down_write(&cgroup_threadgroup_rwsem);
2703         rcu_read_lock();
2704         if (pid) {
2705                 tsk = find_task_by_vpid(pid);
2706                 if (!tsk) {
2707                         ret = -ESRCH;
2708                         goto out_unlock_rcu;
2709                 }
2710         } else {
2711                 tsk = current;
2712         }
2713
2714         if (threadgroup)
2715                 tsk = tsk->group_leader;
2716
2717         /*
2718          * Workqueue threads may acquire PF_NO_SETAFFINITY and become
2719          * trapped in a cpuset, or RT worker may be born in a cgroup
2720          * with no rt_runtime allocated.  Just say no.
2721          */
2722         if (tsk == kthreadd_task || (tsk->flags & PF_NO_SETAFFINITY)) {
2723                 ret = -EINVAL;
2724                 goto out_unlock_rcu;
2725         }
2726
2727         get_task_struct(tsk);
2728         rcu_read_unlock();
2729
2730         ret = cgroup_procs_write_permission(tsk, cgrp, of);
2731         if (!ret)
2732                 ret = cgroup_attach_task(cgrp, tsk, threadgroup);
2733
2734         put_task_struct(tsk);
2735         goto out_unlock_threadgroup;
2736
2737 out_unlock_rcu:
2738         rcu_read_unlock();
2739 out_unlock_threadgroup:
2740         percpu_up_write(&cgroup_threadgroup_rwsem);
2741         cgroup_kn_unlock(of->kn);
2742         return ret ?: nbytes;
2743 }
2744
2745 /**
2746  * cgroup_attach_task_all - attach task 'tsk' to all cgroups of task 'from'
2747  * @from: attach to all cgroups of a given task
2748  * @tsk: the task to be attached
2749  */
2750 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *tsk)
2751 {
2752         struct cgroup_root *root;
2753         int retval = 0;
2754
2755         mutex_lock(&cgroup_mutex);
2756         for_each_root(root) {
2757                 struct cgroup *from_cgrp;
2758
2759                 if (root == &cgrp_dfl_root)
2760                         continue;
2761
2762                 spin_lock_bh(&css_set_lock);
2763                 from_cgrp = task_cgroup_from_root(from, root);
2764                 spin_unlock_bh(&css_set_lock);
2765
2766                 retval = cgroup_attach_task(from_cgrp, tsk, false);
2767                 if (retval)
2768                         break;
2769         }
2770         mutex_unlock(&cgroup_mutex);
2771
2772         return retval;
2773 }
2774 EXPORT_SYMBOL_GPL(cgroup_attach_task_all);
2775
2776 static ssize_t cgroup_tasks_write(struct kernfs_open_file *of,
2777                                   char *buf, size_t nbytes, loff_t off)
2778 {
2779         return __cgroup_procs_write(of, buf, nbytes, off, false);
2780 }
2781
2782 static ssize_t cgroup_procs_write(struct kernfs_open_file *of,
2783                                   char *buf, size_t nbytes, loff_t off)
2784 {
2785         return __cgroup_procs_write(of, buf, nbytes, off, true);
2786 }
2787
2788 static ssize_t cgroup_release_agent_write(struct kernfs_open_file *of,
2789                                           char *buf, size_t nbytes, loff_t off)
2790 {
2791         struct cgroup *cgrp;
2792
2793         BUILD_BUG_ON(sizeof(cgrp->root->release_agent_path) < PATH_MAX);
2794
2795         cgrp = cgroup_kn_lock_live(of->kn);
2796         if (!cgrp)
2797                 return -ENODEV;
2798         spin_lock(&release_agent_path_lock);
2799         strlcpy(cgrp->root->release_agent_path, strstrip(buf),
2800                 sizeof(cgrp->root->release_agent_path));
2801         spin_unlock(&release_agent_path_lock);
2802         cgroup_kn_unlock(of->kn);
2803         return nbytes;
2804 }
2805
2806 static int cgroup_release_agent_show(struct seq_file *seq, void *v)
2807 {
2808         struct cgroup *cgrp = seq_css(seq)->cgroup;
2809
2810         spin_lock(&release_agent_path_lock);
2811         seq_puts(seq, cgrp->root->release_agent_path);
2812         spin_unlock(&release_agent_path_lock);
2813         seq_putc(seq, '\n');
2814         return 0;
2815 }
2816
2817 static int cgroup_sane_behavior_show(struct seq_file *seq, void *v)
2818 {
2819         seq_puts(seq, "0\n");
2820         return 0;
2821 }
2822
2823 static void cgroup_print_ss_mask(struct seq_file *seq, unsigned long ss_mask)
2824 {
2825         struct cgroup_subsys *ss;
2826         bool printed = false;
2827         int ssid;
2828
2829         for_each_subsys_which(ss, ssid, &ss_mask) {
2830                 if (printed)
2831                         seq_putc(seq, ' ');
2832                 seq_printf(seq, "%s", ss->name);
2833                 printed = true;
2834         }
2835         if (printed)
2836                 seq_putc(seq, '\n');
2837 }
2838
2839 /* show controllers which are currently attached to the default hierarchy */
2840 static int cgroup_root_controllers_show(struct seq_file *seq, void *v)
2841 {
2842         struct cgroup *cgrp = seq_css(seq)->cgroup;
2843
2844         cgroup_print_ss_mask(seq, cgrp->root->subsys_mask &
2845                              ~cgrp_dfl_root_inhibit_ss_mask);
2846         return 0;
2847 }
2848
2849 /* show controllers which are enabled from the parent */
2850 static int cgroup_controllers_show(struct seq_file *seq, void *v)
2851 {
2852         struct cgroup *cgrp = seq_css(seq)->cgroup;
2853
2854         cgroup_print_ss_mask(seq, cgroup_parent(cgrp)->subtree_control);
2855         return 0;
2856 }
2857
2858 /* show controllers which are enabled for a given cgroup's children */
2859 static int cgroup_subtree_control_show(struct seq_file *seq, void *v)
2860 {
2861         struct cgroup *cgrp = seq_css(seq)->cgroup;
2862
2863         cgroup_print_ss_mask(seq, cgrp->subtree_control);
2864         return 0;
2865 }
2866
2867 /**
2868  * cgroup_update_dfl_csses - update css assoc of a subtree in default hierarchy
2869  * @cgrp: root of the subtree to update csses for
2870  *
2871  * @cgrp's child_subsys_mask has changed and its subtree's (self excluded)
2872  * css associations need to be updated accordingly.  This function looks up
2873  * all css_sets which are attached to the subtree, creates the matching
2874  * updated css_sets and migrates the tasks to the new ones.
2875  */
2876 static int cgroup_update_dfl_csses(struct cgroup *cgrp)
2877 {
2878         LIST_HEAD(preloaded_csets);
2879         struct cgroup_taskset tset = CGROUP_TASKSET_INIT(tset);
2880         struct cgroup_subsys_state *css;
2881         struct css_set *src_cset;
2882         int ret;
2883
2884         lockdep_assert_held(&cgroup_mutex);
2885
2886         percpu_down_write(&cgroup_threadgroup_rwsem);
2887
2888         /* look up all csses currently attached to @cgrp's subtree */
2889         spin_lock_bh(&css_set_lock);
2890         css_for_each_descendant_pre(css, cgroup_css(cgrp, NULL)) {
2891                 struct cgrp_cset_link *link;
2892
2893                 /* self is not affected by child_subsys_mask change */
2894                 if (css->cgroup == cgrp)
2895                         continue;
2896
2897                 list_for_each_entry(link, &css->cgroup->cset_links, cset_link)
2898                         cgroup_migrate_add_src(link->cset, cgrp,
2899                                                &preloaded_csets);
2900         }
2901         spin_unlock_bh(&css_set_lock);
2902
2903         /* NULL dst indicates self on default hierarchy */
2904         ret = cgroup_migrate_prepare_dst(NULL, &preloaded_csets);
2905         if (ret)
2906                 goto out_finish;
2907
2908         spin_lock_bh(&css_set_lock);
2909         list_for_each_entry(src_cset, &preloaded_csets, mg_preload_node) {
2910                 struct task_struct *task, *ntask;
2911
2912                 /* src_csets precede dst_csets, break on the first dst_cset */
2913                 if (!src_cset->mg_src_cgrp)
2914                         break;
2915
2916                 /* all tasks in src_csets need to be migrated */
2917                 list_for_each_entry_safe(task, ntask, &src_cset->tasks, cg_list)
2918                         cgroup_taskset_add(task, &tset);
2919         }
2920         spin_unlock_bh(&css_set_lock);
2921
2922         ret = cgroup_taskset_migrate(&tset, cgrp);
2923 out_finish:
2924         cgroup_migrate_finish(&preloaded_csets);
2925         percpu_up_write(&cgroup_threadgroup_rwsem);
2926         return ret;
2927 }
2928
2929 /* change the enabled child controllers for a cgroup in the default hierarchy */
2930 static ssize_t cgroup_subtree_control_write(struct kernfs_open_file *of,
2931                                             char *buf, size_t nbytes,
2932                                             loff_t off)
2933 {
2934         unsigned long enable = 0, disable = 0;
2935         unsigned long css_enable, css_disable, old_sc, new_sc, old_ss, new_ss;
2936         struct cgroup *cgrp, *child;
2937         struct cgroup_subsys *ss;
2938         char *tok;
2939         int ssid, ret;
2940
2941         /*
2942          * Parse input - space separated list of subsystem names prefixed
2943          * with either + or -.
2944          */
2945         buf = strstrip(buf);
2946         while ((tok = strsep(&buf, " "))) {
2947                 unsigned long tmp_ss_mask = ~cgrp_dfl_root_inhibit_ss_mask;
2948
2949                 if (tok[0] == '\0')
2950                         continue;
2951                 for_each_subsys_which(ss, ssid, &tmp_ss_mask) {
2952                         if (!cgroup_ssid_enabled(ssid) ||
2953                             strcmp(tok + 1, ss->name))
2954                                 continue;
2955
2956                         if (*tok == '+') {
2957                                 enable |= 1 << ssid;
2958                                 disable &= ~(1 << ssid);
2959                         } else if (*tok == '-') {
2960                                 disable |= 1 << ssid;
2961                                 enable &= ~(1 << ssid);
2962                         } else {
2963                                 return -EINVAL;
2964                         }
2965                         break;
2966                 }
2967                 if (ssid == CGROUP_SUBSYS_COUNT)
2968                         return -EINVAL;
2969         }
2970
2971         cgrp = cgroup_kn_lock_live(of->kn);
2972         if (!cgrp)
2973                 return -ENODEV;
2974
2975         for_each_subsys(ss, ssid) {
2976                 if (enable & (1 << ssid)) {
2977                         if (cgrp->subtree_control & (1 << ssid)) {
2978                                 enable &= ~(1 << ssid);
2979                                 continue;
2980                         }
2981
2982                         /* unavailable or not enabled on the parent? */
2983                         if (!(cgrp_dfl_root.subsys_mask & (1 << ssid)) ||
2984                             (cgroup_parent(cgrp) &&
2985                              !(cgroup_parent(cgrp)->subtree_control & (1 << ssid)))) {
2986                                 ret = -ENOENT;
2987                                 goto out_unlock;
2988                         }
2989                 } else if (disable & (1 << ssid)) {
2990                         if (!(cgrp->subtree_control & (1 << ssid))) {
2991                                 disable &= ~(1 << ssid);
2992                                 continue;
2993                         }
2994
2995                         /* a child has it enabled? */
2996                         cgroup_for_each_live_child(child, cgrp) {
2997                                 if (child->subtree_control & (1 << ssid)) {
2998                                         ret = -EBUSY;
2999                                         goto out_unlock;
3000                                 }
3001                         }
3002                 }
3003         }
3004
3005         if (!enable && !disable) {
3006                 ret = 0;
3007                 goto out_unlock;
3008         }
3009
3010         /*
3011          * Except for the root, subtree_control must be zero for a cgroup
3012          * with tasks so that child cgroups don't compete against tasks.
3013          */
3014         if (enable && cgroup_parent(cgrp) && !list_empty(&cgrp->cset_links)) {
3015                 ret = -EBUSY;
3016                 goto out_unlock;
3017         }
3018
3019         /*
3020          * Update subsys masks and calculate what needs to be done.  More
3021          * subsystems than specified may need to be enabled or disabled
3022          * depending on subsystem dependencies.
3023          */
3024         old_sc = cgrp->subtree_control;
3025         old_ss = cgrp->child_subsys_mask;
3026         new_sc = (old_sc | enable) & ~disable;
3027         new_ss = cgroup_calc_child_subsys_mask(cgrp, new_sc);
3028
3029         css_enable = ~old_ss & new_ss;
3030         css_disable = old_ss & ~new_ss;
3031         enable |= css_enable;
3032         disable |= css_disable;
3033
3034         /*
3035          * Because css offlining is asynchronous, userland might try to
3036          * re-enable the same controller while the previous instance is
3037          * still around.  In such cases, wait till it's gone using
3038          * offline_waitq.
3039          */
3040         for_each_subsys_which(ss, ssid, &css_enable) {
3041                 cgroup_for_each_live_child(child, cgrp) {
3042                         DEFINE_WAIT(wait);
3043
3044                         if (!cgroup_css(child, ss))
3045                                 continue;
3046
3047                         cgroup_get(child);
3048                         prepare_to_wait(&child->offline_waitq, &wait,
3049                                         TASK_UNINTERRUPTIBLE);
3050                         cgroup_kn_unlock(of->kn);
3051                         schedule();
3052                         finish_wait(&child->offline_waitq, &wait);
3053                         cgroup_put(child);
3054
3055                         return restart_syscall();
3056                 }
3057         }
3058
3059         cgrp->subtree_control = new_sc;
3060         cgrp->child_subsys_mask = new_ss;
3061
3062         /*
3063          * Create new csses or make the existing ones visible.  A css is
3064          * created invisible if it's being implicitly enabled through
3065          * dependency.  An invisible css is made visible when the userland
3066          * explicitly enables it.
3067          */
3068         for_each_subsys(ss, ssid) {
3069                 if (!(enable & (1 << ssid)))
3070                         continue;
3071
3072                 cgroup_for_each_live_child(child, cgrp) {
3073                         if (css_enable & (1 << ssid))
3074                                 ret = create_css(child, ss,
3075                                         cgrp->subtree_control & (1 << ssid));
3076                         else
3077                                 ret = css_populate_dir(cgroup_css(child, ss),
3078                                                        NULL);
3079                         if (ret)
3080                                 goto err_undo_css;
3081                 }
3082         }
3083
3084         /*
3085          * At this point, cgroup_e_css() results reflect the new csses
3086          * making the following cgroup_update_dfl_csses() properly update
3087          * css associations of all tasks in the subtree.
3088          */
3089         ret = cgroup_update_dfl_csses(cgrp);
3090         if (ret)
3091                 goto err_undo_css;
3092
3093         /*
3094          * All tasks are migrated out of disabled csses.  Kill or hide
3095          * them.  A css is hidden when the userland requests it to be
3096          * disabled while other subsystems are still depending on it.  The
3097          * css must not actively control resources and be in the vanilla
3098          * state if it's made visible again later.  Controllers which may
3099          * be depended upon should provide ->css_reset() for this purpose.
3100          */
3101         for_each_subsys(ss, ssid) {
3102                 if (!(disable & (1 << ssid)))
3103                         continue;
3104
3105                 cgroup_for_each_live_child(child, cgrp) {
3106                         struct cgroup_subsys_state *css = cgroup_css(child, ss);
3107
3108                         if (css_disable & (1 << ssid)) {
3109                                 kill_css(css);
3110                         } else {
3111                                 css_clear_dir(css, NULL);
3112                                 if (ss->css_reset)
3113                                         ss->css_reset(css);
3114                         }
3115                 }
3116         }
3117
3118         /*
3119          * The effective csses of all the descendants (excluding @cgrp) may
3120          * have changed.  Subsystems can optionally subscribe to this event
3121          * by implementing ->css_e_css_changed() which is invoked if any of
3122          * the effective csses seen from the css's cgroup may have changed.
3123          */
3124         for_each_subsys(ss, ssid) {
3125                 struct cgroup_subsys_state *this_css = cgroup_css(cgrp, ss);
3126                 struct cgroup_subsys_state *css;
3127
3128                 if (!ss->css_e_css_changed || !this_css)
3129                         continue;
3130
3131                 css_for_each_descendant_pre(css, this_css)
3132                         if (css != this_css)
3133                                 ss->css_e_css_changed(css);
3134         }
3135
3136         kernfs_activate(cgrp->kn);
3137         ret = 0;
3138 out_unlock:
3139         cgroup_kn_unlock(of->kn);
3140         return ret ?: nbytes;
3141
3142 err_undo_css:
3143         cgrp->subtree_control = old_sc;
3144         cgrp->child_subsys_mask = old_ss;
3145
3146         for_each_subsys(ss, ssid) {
3147                 if (!(enable & (1 << ssid)))
3148                         continue;
3149
3150                 cgroup_for_each_live_child(child, cgrp) {
3151                         struct cgroup_subsys_state *css = cgroup_css(child, ss);
3152
3153                         if (!css)
3154                                 continue;
3155
3156                         if (css_enable & (1 << ssid))
3157                                 kill_css(css);
3158                         else
3159                                 css_clear_dir(css, NULL);
3160                 }
3161         }
3162         goto out_unlock;
3163 }
3164
3165 static int cgroup_events_show(struct seq_file *seq, void *v)
3166 {
3167         seq_printf(seq, "populated %d\n",
3168                    cgroup_is_populated(seq_css(seq)->cgroup));
3169         return 0;
3170 }
3171
3172 static ssize_t cgroup_file_write(struct kernfs_open_file *of, char *buf,
3173                                  size_t nbytes, loff_t off)
3174 {
3175         struct cgroup *cgrp = of->kn->parent->priv;
3176         struct cftype *cft = of->kn->priv;
3177         struct cgroup_subsys_state *css;
3178         int ret;
3179
3180         if (cft->write)
3181                 return cft->write(of, buf, nbytes, off);
3182
3183         /*
3184          * kernfs guarantees that a file isn't deleted with operations in
3185          * flight, which means that the matching css is and stays alive and
3186          * doesn't need to be pinned.  The RCU locking is not necessary
3187          * either.  It's just for the convenience of using cgroup_css().
3188          */
3189         rcu_read_lock();
3190         css = cgroup_css(cgrp, cft->ss);
3191         rcu_read_unlock();
3192
3193         if (cft->write_u64) {
3194                 unsigned long long v;
3195                 ret = kstrtoull(buf, 0, &v);
3196                 if (!ret)
3197                         ret = cft->write_u64(css, cft, v);
3198         } else if (cft->write_s64) {
3199                 long long v;
3200                 ret = kstrtoll(buf, 0, &v);
3201                 if (!ret)
3202                         ret = cft->write_s64(css, cft, v);
3203         } else {
3204                 ret = -EINVAL;
3205         }
3206
3207         return ret ?: nbytes;
3208 }
3209
3210 static void *cgroup_seqfile_start(struct seq_file *seq, loff_t *ppos)
3211 {
3212         return seq_cft(seq)->seq_start(seq, ppos);
3213 }
3214
3215 static void *cgroup_seqfile_next(struct seq_file *seq, void *v, loff_t *ppos)
3216 {
3217         return seq_cft(seq)->seq_next(seq, v, ppos);
3218 }
3219
3220 static void cgroup_seqfile_stop(struct seq_file *seq, void *v)
3221 {
3222         seq_cft(seq)->seq_stop(seq, v);
3223 }
3224
3225 static int cgroup_seqfile_show(struct seq_file *m, void *arg)
3226 {
3227         struct cftype *cft = seq_cft(m);
3228         struct cgroup_subsys_state *css = seq_css(m);
3229
3230         if (cft->seq_show)
3231                 return cft->seq_show(m, arg);
3232
3233         if (cft->read_u64)
3234                 seq_printf(m, "%llu\n", cft->read_u64(css, cft));
3235         else if (cft->read_s64)
3236                 seq_printf(m, "%lld\n", cft->read_s64(css, cft));
3237         else
3238                 return -EINVAL;
3239         return 0;
3240 }
3241
3242 static struct kernfs_ops cgroup_kf_single_ops = {
3243         .atomic_write_len       = PAGE_SIZE,
3244         .write                  = cgroup_file_write,
3245         .seq_show               = cgroup_seqfile_show,
3246 };
3247
3248 static struct kernfs_ops cgroup_kf_ops = {
3249         .atomic_write_len       = PAGE_SIZE,
3250         .write                  = cgroup_file_write,
3251         .seq_start              = cgroup_seqfile_start,
3252         .seq_next               = cgroup_seqfile_next,
3253         .seq_stop               = cgroup_seqfile_stop,
3254         .seq_show               = cgroup_seqfile_show,
3255 };
3256
3257 /*
3258  * cgroup_rename - Only allow simple rename of directories in place.
3259  */
3260 static int cgroup_rename(struct kernfs_node *kn, struct kernfs_node *new_parent,
3261                          const char *new_name_str)
3262 {
3263         struct cgroup *cgrp = kn->priv;
3264         int ret;
3265
3266         if (kernfs_type(kn) != KERNFS_DIR)
3267                 return -ENOTDIR;
3268         if (kn->parent != new_parent)
3269                 return -EIO;
3270
3271         /*
3272          * This isn't a proper migration and its usefulness is very
3273          * limited.  Disallow on the default hierarchy.
3274          */
3275         if (cgroup_on_dfl(cgrp))
3276                 return -EPERM;
3277
3278         /*
3279          * We're gonna grab cgroup_mutex which nests outside kernfs
3280          * active_ref.  kernfs_rename() doesn't require active_ref
3281          * protection.  Break them before grabbing cgroup_mutex.
3282          */
3283         kernfs_break_active_protection(new_parent);
3284         kernfs_break_active_protection(kn);
3285
3286         mutex_lock(&cgroup_mutex);
3287
3288         ret = kernfs_rename(kn, new_parent, new_name_str);
3289
3290         mutex_unlock(&cgroup_mutex);
3291
3292         kernfs_unbreak_active_protection(kn);
3293         kernfs_unbreak_active_protection(new_parent);
3294         return ret;
3295 }
3296
3297 /* set uid and gid of cgroup dirs and files to that of the creator */
3298 static int cgroup_kn_set_ugid(struct kernfs_node *kn)
3299 {
3300         struct iattr iattr = { .ia_valid = ATTR_UID | ATTR_GID,
3301                                .ia_uid = current_fsuid(),
3302                                .ia_gid = current_fsgid(), };
3303
3304         if (uid_eq(iattr.ia_uid, GLOBAL_ROOT_UID) &&
3305             gid_eq(iattr.ia_gid, GLOBAL_ROOT_GID))
3306                 return 0;
3307
3308         return kernfs_setattr(kn, &iattr);
3309 }
3310
3311 static int cgroup_add_file(struct cgroup_subsys_state *css, struct cgroup *cgrp,
3312                            struct cftype *cft)
3313 {
3314         char name[CGROUP_FILE_NAME_MAX];
3315         struct kernfs_node *kn;
3316         struct lock_class_key *key = NULL;
3317         int ret;
3318
3319 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3320         key = &cft->lockdep_key;
3321 #endif
3322         kn = __kernfs_create_file(cgrp->kn, cgroup_file_name(cgrp, cft, name),
3323                                   cgroup_file_mode(cft), 0, cft->kf_ops, cft,
3324                                   NULL, key);
3325         if (IS_ERR(kn))
3326                 return PTR_ERR(kn);
3327
3328         ret = cgroup_kn_set_ugid(kn);
3329         if (ret) {
3330                 kernfs_remove(kn);
3331                 return ret;
3332         }
3333
3334         if (cft->file_offset) {
3335                 struct cgroup_file *cfile = (void *)css + cft->file_offset;
3336
3337                 spin_lock_irq(&cgroup_file_kn_lock);
3338                 cfile->kn = kn;
3339                 spin_unlock_irq(&cgroup_file_kn_lock);
3340         }
3341
3342         return 0;
3343 }
3344
3345 /**
3346  * cgroup_addrm_files - add or remove files to a cgroup directory
3347  * @css: the target css
3348  * @cgrp: the target cgroup (usually css->cgroup)
3349  * @cfts: array of cftypes to be added
3350  * @is_add: whether to add or remove
3351  *
3352  * Depending on @is_add, add or remove files defined by @cfts on @cgrp.
3353  * For removals, this function never fails.
3354  */
3355 static int cgroup_addrm_files(struct cgroup_subsys_state *css,
3356                               struct cgroup *cgrp, struct cftype cfts[],
3357                               bool is_add)
3358 {
3359         struct cftype *cft, *cft_end = NULL;
3360         int ret;
3361
3362         lockdep_assert_held(&cgroup_mutex);
3363
3364 restart:
3365         for (cft = cfts; cft != cft_end && cft->name[0] != '\0'; cft++) {
3366                 /* does cft->flags tell us to skip this file on @cgrp? */
3367                 if ((cft->flags & __CFTYPE_ONLY_ON_DFL) && !cgroup_on_dfl(cgrp))
3368                         continue;
3369                 if ((cft->flags & __CFTYPE_NOT_ON_DFL) && cgroup_on_dfl(cgrp))
3370                         continue;
3371                 if ((cft->flags & CFTYPE_NOT_ON_ROOT) && !cgroup_parent(cgrp))
3372                         continue;
3373                 if ((cft->flags & CFTYPE_ONLY_ON_ROOT) && cgroup_parent(cgrp))
3374                         continue;
3375
3376                 if (is_add) {
3377                         ret = cgroup_add_file(css, cgrp, cft);
3378                         if (ret) {
3379                                 pr_warn("%s: failed to add %s, err=%d\n",
3380                                         __func__, cft->name, ret);
3381                                 cft_end = cft;
3382                                 is_add = false;
3383                                 goto restart;
3384                         }
3385                 } else {
3386                         cgroup_rm_file(cgrp, cft);
3387                 }
3388         }
3389         return 0;
3390 }
3391
3392 static int cgroup_apply_cftypes(struct cftype *cfts, bool is_add)
3393 {
3394         LIST_HEAD(pending);
3395         struct cgroup_subsys *ss = cfts[0].ss;
3396         struct cgroup *root = &ss->root->cgrp;
3397         struct cgroup_subsys_state *css;
3398         int ret = 0;
3399
3400         lockdep_assert_held(&cgroup_mutex);
3401
3402         /* add/rm files for all cgroups created before */
3403         css_for_each_descendant_pre(css, cgroup_css(root, ss)) {
3404                 struct cgroup *cgrp = css->cgroup;
3405
3406                 if (cgroup_is_dead(cgrp))
3407                         continue;
3408
3409                 ret = cgroup_addrm_files(css, cgrp, cfts, is_add);
3410                 if (ret)
3411                         break;
3412         }
3413
3414         if (is_add && !ret)
3415                 kernfs_activate(root->kn);
3416         return ret;
3417 }
3418
3419 static void cgroup_exit_cftypes(struct cftype *cfts)
3420 {
3421         struct cftype *cft;
3422
3423         for (cft = cfts; cft->name[0] != '\0'; cft++) {
3424                 /* free copy for custom atomic_write_len, see init_cftypes() */
3425                 if (cft->max_write_len && cft->max_write_len != PAGE_SIZE)
3426                         kfree(cft->kf_ops);
3427                 cft->kf_ops = NULL;
3428                 cft->ss = NULL;
3429
3430                 /* revert flags set by cgroup core while adding @cfts */
3431                 cft->flags &= ~(__CFTYPE_ONLY_ON_DFL | __CFTYPE_NOT_ON_DFL);
3432         }
3433 }
3434
3435 static int cgroup_init_cftypes(struct cgroup_subsys *ss, struct cftype *cfts)
3436 {
3437         struct cftype *cft;
3438
3439         for (cft = cfts; cft->name[0] != '\0'; cft++) {
3440                 struct kernfs_ops *kf_ops;
3441
3442                 WARN_ON(cft->ss || cft->kf_ops);
3443
3444                 if (cft->seq_start)
3445                         kf_ops = &cgroup_kf_ops;
3446                 else
3447                         kf_ops = &cgroup_kf_single_ops;
3448
3449                 /*
3450                  * Ugh... if @cft wants a custom max_write_len, we need to
3451                  * make a copy of kf_ops to set its atomic_write_len.
3452                  */
3453                 if (cft->max_write_len && cft->max_write_len != PAGE_SIZE) {
3454                         kf_ops = kmemdup(kf_ops, sizeof(*kf_ops), GFP_KERNEL);
3455                         if (!kf_ops) {
3456                                 cgroup_exit_cftypes(cfts);
3457                                 return -ENOMEM;
3458                         }
3459                         kf_ops->atomic_write_len = cft->max_write_len;
3460                 }
3461
3462                 cft->kf_ops = kf_ops;
3463                 cft->ss = ss;
3464         }
3465
3466         return 0;
3467 }
3468
3469 static int cgroup_rm_cftypes_locked(struct cftype *cfts)
3470 {
3471         lockdep_assert_held(&cgroup_mutex);
3472
3473         if (!cfts || !cfts[0].ss)
3474                 return -ENOENT;
3475
3476         list_del(&cfts->node);
3477         cgroup_apply_cftypes(cfts, false);
3478         cgroup_exit_cftypes(cfts);
3479         return 0;
3480 }
3481
3482 /**
3483  * cgroup_rm_cftypes - remove an array of cftypes from a subsystem
3484  * @cfts: zero-length name terminated array of cftypes
3485  *
3486  * Unregister @cfts.  Files described by @cfts are removed from all
3487  * existing cgroups and all future cgroups won't have them either.  This
3488  * function can be called anytime whether @cfts' subsys is attached or not.
3489  *
3490  * Returns 0 on successful unregistration, -ENOENT if @cfts is not
3491  * registered.
3492  */
3493 int cgroup_rm_cftypes(struct cftype *cfts)
3494 {
3495         int ret;
3496
3497         mutex_lock(&cgroup_mutex);
3498         ret = cgroup_rm_cftypes_locked(cfts);
3499         mutex_unlock(&cgroup_mutex);
3500         return ret;
3501 }
3502
3503 /**
3504  * cgroup_add_cftypes - add an array of cftypes to a subsystem
3505  * @ss: target cgroup subsystem
3506  * @cfts: zero-length name terminated array of cftypes
3507  *
3508  * Register @cfts to @ss.  Files described by @cfts are created for all
3509  * existing cgroups to which @ss is attached and all future cgroups will
3510  * have them too.  This function can be called anytime whether @ss is
3511  * attached or not.
3512  *
3513  * Returns 0 on successful registration, -errno on failure.  Note that this
3514  * function currently returns 0 as long as @cfts registration is successful
3515  * even if some file creation attempts on existing cgroups fail.
3516  */
3517 static int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts)
3518 {
3519         int ret;
3520
3521         if (!cgroup_ssid_enabled(ss->id))
3522                 return 0;
3523
3524         if (!cfts || cfts[0].name[0] == '\0')
3525                 return 0;
3526
3527         ret = cgroup_init_cftypes(ss, cfts);
3528         if (ret)
3529                 return ret;
3530
3531         mutex_lock(&cgroup_mutex);
3532
3533         list_add_tail(&cfts->node, &ss->cfts);
3534         ret = cgroup_apply_cftypes(cfts, true);
3535         if (ret)
3536                 cgroup_rm_cftypes_locked(cfts);
3537
3538         mutex_unlock(&cgroup_mutex);
3539         return ret;
3540 }
3541
3542 /**
3543  * cgroup_add_dfl_cftypes - add an array of cftypes for default hierarchy
3544  * @ss: target cgroup subsystem
3545  * @cfts: zero-length name terminated array of cftypes
3546  *
3547  * Similar to cgroup_add_cftypes() but the added files are only used for
3548  * the default hierarchy.
3549  */
3550 int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts)
3551 {
3552         struct cftype *cft;
3553
3554         for (cft = cfts; cft && cft->name[0] != '\0'; cft++)
3555                 cft->flags |= __CFTYPE_ONLY_ON_DFL;
3556         return cgroup_add_cftypes(ss, cfts);
3557 }
3558
3559 /**
3560  * cgroup_add_legacy_cftypes - add an array of cftypes for legacy hierarchies
3561  * @ss: target cgroup subsystem
3562  * @cfts: zero-length name terminated array of cftypes
3563  *
3564  * Similar to cgroup_add_cftypes() but the added files are only used for
3565  * the legacy hierarchies.
3566  */
3567 int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts)
3568 {
3569         struct cftype *cft;
3570
3571         for (cft = cfts; cft && cft->name[0] != '\0'; cft++)
3572                 cft->flags |= __CFTYPE_NOT_ON_DFL;
3573         return cgroup_add_cftypes(ss, cfts);
3574 }
3575
3576 /**
3577  * cgroup_file_notify - generate a file modified event for a cgroup_file
3578  * @cfile: target cgroup_file
3579  *
3580  * @cfile must have been obtained by setting cftype->file_offset.
3581  */
3582 void cgroup_file_notify(struct cgroup_file *cfile)
3583 {
3584         unsigned long flags;
3585
3586         spin_lock_irqsave(&cgroup_file_kn_lock, flags);
3587         if (cfile->kn)
3588                 kernfs_notify(cfile->kn);
3589         spin_unlock_irqrestore(&cgroup_file_kn_lock, flags);
3590 }
3591
3592 /**
3593  * cgroup_task_count - count the number of tasks in a cgroup.
3594  * @cgrp: the cgroup in question
3595  *
3596  * Return the number of tasks in the cgroup.
3597  */
3598 static int cgroup_task_count(const struct cgroup *cgrp)
3599 {
3600         int count = 0;
3601         struct cgrp_cset_link *link;
3602
3603         spin_lock_bh(&css_set_lock);
3604         list_for_each_entry(link, &cgrp->cset_links, cset_link)
3605                 count += atomic_read(&link->cset->refcount);
3606         spin_unlock_bh(&css_set_lock);
3607         return count;
3608 }
3609
3610 /**
3611  * css_next_child - find the next child of a given css
3612  * @pos: the current position (%NULL to initiate traversal)
3613  * @parent: css whose children to walk
3614  *
3615  * This function returns the next child of @parent and should be called
3616  * under either cgroup_mutex or RCU read lock.  The only requirement is
3617  * that @parent and @pos are accessible.  The next sibling is guaranteed to
3618  * be returned regardless of their states.
3619  *
3620  * If a subsystem synchronizes ->css_online() and the start of iteration, a
3621  * css which finished ->css_online() is guaranteed to be visible in the
3622  * future iterations and will stay visible until the last reference is put.
3623  * A css which hasn't finished ->css_online() or already finished
3624  * ->css_offline() may show up during traversal.  It's each subsystem's
3625  * responsibility to synchronize against on/offlining.
3626  */
3627 struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
3628                                            struct cgroup_subsys_state *parent)
3629 {
3630         struct cgroup_subsys_state *next;
3631
3632         cgroup_assert_mutex_or_rcu_locked();
3633
3634         /*
3635          * @pos could already have been unlinked from the sibling list.
3636          * Once a cgroup is removed, its ->sibling.next is no longer
3637          * updated when its next sibling changes.  CSS_RELEASED is set when
3638          * @pos is taken off list, at which time its next pointer is valid,
3639          * and, as releases are serialized, the one pointed to by the next
3640          * pointer is guaranteed to not have started release yet.  This
3641          * implies that if we observe !CSS_RELEASED on @pos in this RCU
3642          * critical section, the one pointed to by its next pointer is
3643          * guaranteed to not have finished its RCU grace period even if we
3644          * have dropped rcu_read_lock() inbetween iterations.
3645          *
3646          * If @pos has CSS_RELEASED set, its next pointer can't be
3647          * dereferenced; however, as each css is given a monotonically
3648          * increasing unique serial number and always appended to the
3649          * sibling list, the next one can be found by walking the parent's
3650          * children until the first css with higher serial number than
3651          * @pos's.  While this path can be slower, it happens iff iteration
3652          * races against release and the race window is very small.
3653          */
3654         if (!pos) {
3655                 next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling);
3656         } else if (likely(!(pos->flags & CSS_RELEASED))) {
3657                 next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling);
3658         } else {
3659                 list_for_each_entry_rcu(next, &parent->children, sibling)
3660                         if (next->serial_nr > pos->serial_nr)
3661                                 break;
3662         }
3663
3664         /*
3665          * @next, if not pointing to the head, can be dereferenced and is
3666          * the next sibling.
3667          */
3668         if (&next->sibling != &parent->children)
3669                 return next;
3670         return NULL;
3671 }
3672
3673 /**
3674  * css_next_descendant_pre - find the next descendant for pre-order walk
3675  * @pos: the current position (%NULL to initiate traversal)
3676  * @root: css whose descendants to walk
3677  *
3678  * To be used by css_for_each_descendant_pre().  Find the next descendant
3679  * to visit for pre-order traversal of @root's descendants.  @root is
3680  * included in the iteration and the first node to be visited.
3681  *
3682  * While this function requires cgroup_mutex or RCU read locking, it
3683  * doesn't require the whole traversal to be contained in a single critical
3684  * section.  This function will return the correct next descendant as long
3685  * as both @pos and @root are accessible and @pos is a descendant of @root.
3686  *
3687  * If a subsystem synchronizes ->css_online() and the start of iteration, a
3688  * css which finished ->css_online() is guaranteed to be visible in the
3689  * future iterations and will stay visible until the last reference is put.
3690  * A css which hasn't finished ->css_online() or already finished
3691  * ->css_offline() may show up during traversal.  It's each subsystem's
3692  * responsibility to synchronize against on/offlining.
3693  */
3694 struct cgroup_subsys_state *
3695 css_next_descendant_pre(struct cgroup_subsys_state *pos,
3696                         struct cgroup_subsys_state *root)
3697 {
3698         struct cgroup_subsys_state *next;
3699
3700         cgroup_assert_mutex_or_rcu_locked();
3701
3702         /* if first iteration, visit @root */
3703         if (!pos)
3704                 return root;
3705
3706         /* visit the first child if exists */
3707         next = css_next_child(NULL, pos);
3708         if (next)
3709                 return next;
3710
3711         /* no child, visit my or the closest ancestor's next sibling */
3712         while (pos != root) {
3713                 next = css_next_child(pos, pos->parent);
3714                 if (next)
3715                         return next;
3716                 pos = pos->parent;
3717         }
3718
3719         return NULL;
3720 }
3721
3722 /**
3723  * css_rightmost_descendant - return the rightmost descendant of a css
3724  * @pos: css of interest
3725  *
3726  * Return the rightmost descendant of @pos.  If there's no descendant, @pos
3727  * is returned.  This can be used during pre-order traversal to skip
3728  * subtree of @pos.
3729  *
3730  * While this function requires cgroup_mutex or RCU read locking, it
3731  * doesn't require the whole traversal to be contained in a single critical
3732  * section.  This function will return the correct rightmost descendant as
3733  * long as @pos is accessible.
3734  */
3735 struct cgroup_subsys_state *
3736 css_rightmost_descendant(struct cgroup_subsys_state *pos)
3737 {
3738         struct cgroup_subsys_state *last, *tmp;
3739
3740         cgroup_assert_mutex_or_rcu_locked();
3741
3742         do {
3743                 last = pos;
3744                 /* ->prev isn't RCU safe, walk ->next till the end */
3745                 pos = NULL;
3746                 css_for_each_child(tmp, last)
3747                         pos = tmp;
3748         } while (pos);
3749
3750         return last;
3751 }
3752
3753 static struct cgroup_subsys_state *
3754 css_leftmost_descendant(struct cgroup_subsys_state *pos)
3755 {
3756         struct cgroup_subsys_state *last;
3757
3758         do {
3759                 last = pos;
3760                 pos = css_next_child(NULL, pos);
3761         } while (pos);
3762
3763         return last;
3764 }
3765
3766 /**
3767  * css_next_descendant_post - find the next descendant for post-order walk
3768  * @pos: the current position (%NULL to initiate traversal)
3769  * @root: css whose descendants to walk
3770  *
3771  * To be used by css_for_each_descendant_post().  Find the next descendant
3772  * to visit for post-order traversal of @root's descendants.  @root is
3773  * included in the iteration and the last node to be visited.
3774  *
3775  * While this function requires cgroup_mutex or RCU read locking, it
3776  * doesn't require the whole traversal to be contained in a single critical
3777  * section.  This function will return the correct next descendant as long
3778  * as both @pos and @cgroup are accessible and @pos is a descendant of
3779  * @cgroup.
3780  *
3781  * If a subsystem synchronizes ->css_online() and the start of iteration, a
3782  * css which finished ->css_online() is guaranteed to be visible in the
3783  * future iterations and will stay visible until the last reference is put.
3784  * A css which hasn't finished ->css_online() or already finished
3785  * ->css_offline() may show up during traversal.  It's each subsystem's
3786  * responsibility to synchronize against on/offlining.
3787  */
3788 struct cgroup_subsys_state *
3789 css_next_descendant_post(struct cgroup_subsys_state *pos,
3790                          struct cgroup_subsys_state *root)
3791 {
3792         struct cgroup_subsys_state *next;
3793
3794         cgroup_assert_mutex_or_rcu_locked();
3795
3796         /* if first iteration, visit leftmost descendant which may be @root */
3797         if (!pos)
3798                 return css_leftmost_descendant(root);
3799
3800         /* if we visited @root, we're done */
3801         if (pos == root)
3802                 return NULL;
3803
3804         /* if there's an unvisited sibling, visit its leftmost descendant */
3805         next = css_next_child(pos, pos->parent);
3806         if (next)
3807                 return css_leftmost_descendant(next);
3808
3809         /* no sibling left, visit parent */
3810         return pos->parent;
3811 }
3812
3813 /**
3814  * css_has_online_children - does a css have online children
3815  * @css: the target css
3816  *
3817  * Returns %true if @css has any online children; otherwise, %false.  This
3818  * function can be called from any context but the caller is responsible
3819  * for synchronizing against on/offlining as necessary.
3820  */
3821 bool css_has_online_children(struct cgroup_subsys_state *css)
3822 {
3823         struct cgroup_subsys_state *child;
3824         bool ret = false;
3825
3826         rcu_read_lock();
3827         css_for_each_child(child, css) {
3828                 if (child->flags & CSS_ONLINE) {
3829                         ret = true;
3830                         break;
3831                 }
3832         }
3833         rcu_read_unlock();
3834         return ret;
3835 }
3836
3837 /**
3838  * css_task_iter_advance_css_set - advance a task itererator to the next css_set
3839  * @it: the iterator to advance
3840  *
3841  * Advance @it to the next css_set to walk.
3842  */
3843 static void css_task_iter_advance_css_set(struct css_task_iter *it)
3844 {
3845         struct list_head *l = it->cset_pos;
3846         struct cgrp_cset_link *link;
3847         struct css_set *cset;
3848
3849         lockdep_assert_held(&css_set_lock);
3850
3851         /* Advance to the next non-empty css_set */
3852         do {
3853                 l = l->next;
3854                 if (l == it->cset_head) {
3855                         it->cset_pos = NULL;
3856                         it->task_pos = NULL;
3857                         return;
3858                 }
3859
3860                 if (it->ss) {
3861                         cset = container_of(l, struct css_set,
3862                                             e_cset_node[it->ss->id]);
3863                 } else {
3864                         link = list_entry(l, struct cgrp_cset_link, cset_link);
3865                         cset = link->cset;
3866                 }
3867         } while (!css_set_populated(cset));
3868
3869         it->cset_pos = l;
3870
3871         if (!list_empty(&cset->tasks))
3872                 it->task_pos = cset->tasks.next;
3873         else
3874                 it->task_pos = cset->mg_tasks.next;
3875
3876         it->tasks_head = &cset->tasks;
3877         it->mg_tasks_head = &cset->mg_tasks;
3878
3879         /*
3880          * We don't keep css_sets locked across iteration steps and thus
3881          * need to take steps to ensure that iteration can be resumed after
3882          * the lock is re-acquired.  Iteration is performed at two levels -
3883          * css_sets and tasks in them.
3884          *
3885          * Once created, a css_set never leaves its cgroup lists, so a
3886          * pinned css_set is guaranteed to stay put and we can resume
3887          * iteration afterwards.
3888          *
3889          * Tasks may leave @cset across iteration steps.  This is resolved
3890          * by registering each iterator with the css_set currently being
3891          * walked and making css_set_move_task() advance iterators whose
3892          * next task is leaving.
3893          */
3894         if (it->cur_cset) {
3895                 list_del(&it->iters_node);
3896                 put_css_set_locked(it->cur_cset);
3897         }
3898         get_css_set(cset);
3899         it->cur_cset = cset;
3900         list_add(&it->iters_node, &cset->task_iters);
3901 }
3902
3903 static void css_task_iter_advance(struct css_task_iter *it)
3904 {
3905         struct list_head *l = it->task_pos;
3906
3907         lockdep_assert_held(&css_set_lock);
3908         WARN_ON_ONCE(!l);
3909
3910         /*
3911          * Advance iterator to find next entry.  cset->tasks is consumed
3912          * first and then ->mg_tasks.  After ->mg_tasks, we move onto the
3913          * next cset.
3914          */
3915         l = l->next;
3916
3917         if (l == it->tasks_head)
3918                 l = it->mg_tasks_head->next;
3919
3920         if (l == it->mg_tasks_head)
3921                 css_task_iter_advance_css_set(it);
3922         else
3923                 it->task_pos = l;
3924 }
3925
3926 /**
3927  * css_task_iter_start - initiate task iteration
3928  * @css: the css to walk tasks of
3929  * @it: the task iterator to use
3930  *
3931  * Initiate iteration through the tasks of @css.  The caller can call
3932  * css_task_iter_next() to walk through the tasks until the function
3933  * returns NULL.  On completion of iteration, css_task_iter_end() must be
3934  * called.
3935  */
3936 void css_task_iter_start(struct cgroup_subsys_state *css,
3937                          struct css_task_iter *it)
3938 {
3939         /* no one should try to iterate before mounting cgroups */
3940         WARN_ON_ONCE(!use_task_css_set_links);
3941
3942         memset(it, 0, sizeof(*it));
3943
3944         spin_lock_bh(&css_set_lock);
3945
3946         it->ss = css->ss;
3947
3948         if (it->ss)
3949                 it->cset_pos = &css->cgroup->e_csets[css->ss->id];
3950         else
3951                 it->cset_pos = &css->cgroup->cset_links;
3952
3953         it->cset_head = it->cset_pos;
3954
3955         css_task_iter_advance_css_set(it);
3956
3957         spin_unlock_bh(&css_set_lock);
3958 }
3959
3960 /**
3961  * css_task_iter_next - return the next task for the iterator
3962  * @it: the task iterator being iterated
3963  *
3964  * The "next" function for task iteration.  @it should have been
3965  * initialized via css_task_iter_start().  Returns NULL when the iteration
3966  * reaches the end.
3967  */
3968 struct task_struct *css_task_iter_next(struct css_task_iter *it)
3969 {
3970         if (it->cur_task) {
3971                 put_task_struct(it->cur_task);
3972                 it->cur_task = NULL;
3973         }
3974
3975         spin_lock_bh(&css_set_lock);
3976
3977         if (it->task_pos) {
3978                 it->cur_task = list_entry(it->task_pos, struct task_struct,
3979                                           cg_list);
3980                 get_task_struct(it->cur_task);
3981                 css_task_iter_advance(it);
3982         }
3983
3984         spin_unlock_bh(&css_set_lock);
3985
3986         return it->cur_task;
3987 }
3988
3989 /**
3990  * css_task_iter_end - finish task iteration
3991  * @it: the task iterator to finish
3992  *
3993  * Finish task iteration started by css_task_iter_start().
3994  */
3995 void css_task_iter_end(struct css_task_iter *it)
3996 {
3997         if (it->cur_cset) {
3998                 spin_lock_bh(&css_set_lock);
3999                 list_del(&it->iters_node);
4000                 put_css_set_locked(it->cur_cset);
4001                 spin_unlock_bh(&css_set_lock);
4002         }
4003
4004         if (it->cur_task)
4005                 put_task_struct(it->cur_task);
4006 }
4007
4008 /**
4009  * cgroup_trasnsfer_tasks - move tasks from one cgroup to another
4010  * @to: cgroup to which the tasks will be moved
4011  * @from: cgroup in which the tasks currently reside
4012  *
4013  * Locking rules between cgroup_post_fork() and the migration path
4014  * guarantee that, if a task is forking while being migrated, the new child
4015  * is guaranteed to be either visible in the source cgroup after the
4016  * parent's migration is complete or put into the target cgroup.  No task
4017  * can slip out of migration through forking.
4018  */
4019 int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from)
4020 {
4021         LIST_HEAD(preloaded_csets);
4022         struct cgrp_cset_link *link;
4023         struct css_task_iter it;
4024         struct task_struct *task;
4025         int ret;
4026
4027         mutex_lock(&cgroup_mutex);
4028
4029         /* all tasks in @from are being moved, all csets are source */
4030         spin_lock_bh(&css_set_lock);
4031         list_for_each_entry(link, &from->cset_links, cset_link)
4032                 cgroup_migrate_add_src(link->cset, to, &preloaded_csets);
4033         spin_unlock_bh(&css_set_lock);
4034
4035         ret = cgroup_migrate_prepare_dst(to, &preloaded_csets);
4036         if (ret)
4037                 goto out_err;
4038
4039         /*
4040          * Migrate tasks one-by-one until @from is empty.  This fails iff
4041          * ->can_attach() fails.
4042          */
4043         do {
4044                 css_task_iter_start(&from->self, &it);
4045                 task = css_task_iter_next(&it);
4046                 if (task)
4047                         get_task_struct(task);
4048                 css_task_iter_end(&it);
4049
4050                 if (task) {
4051                         ret = cgroup_migrate(task, false, to);
4052                         put_task_struct(task);
4053                 }
4054         } while (task && !ret);
4055 out_err:
4056         cgroup_migrate_finish(&preloaded_csets);
4057         mutex_unlock(&cgroup_mutex);
4058         return ret;
4059 }
4060
4061 /*
4062  * Stuff for reading the 'tasks'/'procs' files.
4063  *
4064  * Reading this file can return large amounts of data if a cgroup has
4065  * *lots* of attached tasks. So it may need several calls to read(),
4066  * but we cannot guarantee that the information we produce is correct
4067  * unless we produce it entirely atomically.
4068  *
4069  */
4070
4071 /* which pidlist file are we talking about? */
4072 enum cgroup_filetype {
4073         CGROUP_FILE_PROCS,
4074         CGROUP_FILE_TASKS,
4075 };
4076
4077 /*
4078  * A pidlist is a list of pids that virtually represents the contents of one
4079  * of the cgroup files ("procs" or "tasks"). We keep a list of such pidlists,
4080  * a pair (one each for procs, tasks) for each pid namespace that's relevant
4081  * to the cgroup.
4082  */
4083 struct cgroup_pidlist {
4084         /*
4085          * used to find which pidlist is wanted. doesn't change as long as
4086          * this particular list stays in the list.
4087         */
4088         struct { enum cgroup_filetype type; struct pid_namespace *ns; } key;
4089         /* array of xids */
4090         pid_t *list;
4091         /* how many elements the above list has */
4092         int length;
4093         /* each of these stored in a list by its cgroup */
4094         struct list_head links;
4095         /* pointer to the cgroup we belong to, for list removal purposes */
4096         struct cgroup *owner;
4097         /* for delayed destruction */
4098         struct delayed_work destroy_dwork;
4099 };
4100
4101 /*
4102  * The following two functions "fix" the issue where there are more pids
4103  * than kmalloc will give memory for; in such cases, we use vmalloc/vfree.
4104  * TODO: replace with a kernel-wide solution to this problem
4105  */
4106 #define PIDLIST_TOO_LARGE(c) ((c) * sizeof(pid_t) > (PAGE_SIZE * 2))
4107 static void *pidlist_allocate(int count)
4108 {
4109         if (PIDLIST_TOO_LARGE(count))
4110                 return vmalloc(count * sizeof(pid_t));
4111         else
4112                 return kmalloc(count * sizeof(pid_t), GFP_KERNEL);
4113 }
4114
4115 static void pidlist_free(void *p)
4116 {
4117         kvfree(p);
4118 }
4119
4120 /*
4121  * Used to destroy all pidlists lingering waiting for destroy timer.  None
4122  * should be left afterwards.
4123  */
4124 static void cgroup_pidlist_destroy_all(struct cgroup *cgrp)
4125 {
4126         struct cgroup_pidlist *l, *tmp_l;
4127
4128         mutex_lock(&cgrp->pidlist_mutex);
4129         list_for_each_entry_safe(l, tmp_l, &cgrp->pidlists, links)
4130                 mod_delayed_work(cgroup_pidlist_destroy_wq, &l->destroy_dwork, 0);
4131         mutex_unlock(&cgrp->pidlist_mutex);
4132
4133         flush_workqueue(cgroup_pidlist_destroy_wq);
4134         BUG_ON(!list_empty(&cgrp->pidlists));
4135 }
4136
4137 static void cgroup_pidlist_destroy_work_fn(struct work_struct *work)
4138 {
4139         struct delayed_work *dwork = to_delayed_work(work);
4140         struct cgroup_pidlist *l = container_of(dwork, struct cgroup_pidlist,
4141                                                 destroy_dwork);
4142         struct cgroup_pidlist *tofree = NULL;
4143
4144         mutex_lock(&l->owner->pidlist_mutex);
4145
4146         /*
4147          * Destroy iff we didn't get queued again.  The state won't change
4148          * as destroy_dwork can only be queued while locked.
4149          */
4150         if (!delayed_work_pending(dwork)) {
4151                 list_del(&l->links);
4152                 pidlist_free(l->list);
4153                 put_pid_ns(l->key.ns);
4154                 tofree = l;
4155         }
4156
4157         mutex_unlock(&l->owner->pidlist_mutex);
4158         kfree(tofree);
4159 }
4160
4161 /*
4162  * pidlist_uniq - given a kmalloc()ed list, strip out all duplicate entries
4163  * Returns the number of unique elements.
4164  */
4165 static int pidlist_uniq(pid_t *list, int length)
4166 {
4167         int src, dest = 1;
4168
4169         /*
4170          * we presume the 0th element is unique, so i starts at 1. trivial
4171          * edge cases first; no work needs to be done for either
4172          */
4173         if (length == 0 || length == 1)
4174                 return length;
4175         /* src and dest walk down the list; dest counts unique elements */
4176         for (src = 1; src < length; src++) {
4177                 /* find next unique element */
4178                 while (list[src] == list[src-1]) {
4179                         src++;
4180                         if (src == length)
4181                                 goto after;
4182                 }
4183                 /* dest always points to where the next unique element goes */
4184                 list[dest] = list[src];
4185                 dest++;
4186         }
4187 after:
4188         return dest;
4189 }
4190
4191 /*
4192  * The two pid files - task and cgroup.procs - guaranteed that the result
4193  * is sorted, which forced this whole pidlist fiasco.  As pid order is
4194  * different per namespace, each namespace needs differently sorted list,
4195  * making it impossible to use, for example, single rbtree of member tasks
4196  * sorted by task pointer.  As pidlists can be fairly large, allocating one
4197  * per open file is dangerous, so cgroup had to implement shared pool of
4198  * pidlists keyed by cgroup and namespace.
4199  *
4200  * All this extra complexity was caused by the original implementation
4201  * committing to an entirely unnecessary property.  In the long term, we
4202  * want to do away with it.  Explicitly scramble sort order if on the
4203  * default hierarchy so that no such expectation exists in the new
4204  * interface.
4205  *
4206  * Scrambling is done by swapping every two consecutive bits, which is
4207  * non-identity one-to-one mapping which disturbs sort order sufficiently.
4208  */
4209 static pid_t pid_fry(pid_t pid)
4210 {
4211         unsigned a = pid & 0x55555555;
4212         unsigned b = pid & 0xAAAAAAAA;
4213
4214         return (a << 1) | (b >> 1);
4215 }
4216
4217 static pid_t cgroup_pid_fry(struct cgroup *cgrp, pid_t pid)
4218 {
4219         if (cgroup_on_dfl(cgrp))
4220                 return pid_fry(pid);
4221         else
4222                 return pid;
4223 }
4224
4225 static int cmppid(const void *a, const void *b)
4226 {
4227         return *(pid_t *)a - *(pid_t *)b;
4228 }
4229
4230 static int fried_cmppid(const void *a, const void *b)
4231 {
4232         return pid_fry(*(pid_t *)a) - pid_fry(*(pid_t *)b);
4233 }
4234
4235 static struct cgroup_pidlist *cgroup_pidlist_find(struct cgroup *cgrp,
4236                                                   enum cgroup_filetype type)
4237 {
4238         struct cgroup_pidlist *l;
4239         /* don't need task_nsproxy() if we're looking at ourself */
4240         struct pid_namespace *ns = task_active_pid_ns(current);
4241
4242         lockdep_assert_held(&cgrp->pidlist_mutex);
4243
4244         list_for_each_entry(l, &cgrp->pidlists, links)
4245                 if (l->key.type == type && l->key.ns == ns)
4246                         return l;
4247         return NULL;
4248 }
4249
4250 /*
4251  * find the appropriate pidlist for our purpose (given procs vs tasks)
4252  * returns with the lock on that pidlist already held, and takes care
4253  * of the use count, or returns NULL with no locks held if we're out of
4254  * memory.
4255  */
4256 static struct cgroup_pidlist *cgroup_pidlist_find_create(struct cgroup *cgrp,
4257                                                 enum cgroup_filetype type)
4258 {
4259         struct cgroup_pidlist *l;
4260
4261         lockdep_assert_held(&cgrp->pidlist_mutex);
4262
4263         l = cgroup_pidlist_find(cgrp, type);
4264         if (l)
4265                 return l;
4266
4267         /* entry not found; create a new one */
4268         l = kzalloc(sizeof(struct cgroup_pidlist), GFP_KERNEL);
4269         if (!l)
4270                 return l;
4271
4272         INIT_DELAYED_WORK(&l->destroy_dwork, cgroup_pidlist_destroy_work_fn);
4273         l->key.type = type;
4274         /* don't need task_nsproxy() if we're looking at ourself */
4275         l->key.ns = get_pid_ns(task_active_pid_ns(current));
4276         l->owner = cgrp;
4277         list_add(&l->links, &cgrp->pidlists);
4278         return l;
4279 }
4280
4281 /*
4282  * Load a cgroup's pidarray with either procs' tgids or tasks' pids
4283  */
4284 static int pidlist_array_load(struct cgroup *cgrp, enum cgroup_filetype type,
4285                               struct cgroup_pidlist **lp)
4286 {
4287         pid_t *array;
4288         int length;
4289         int pid, n = 0; /* used for populating the array */
4290         struct css_task_iter it;
4291         struct task_struct *tsk;
4292         struct cgroup_pidlist *l;
4293
4294         lockdep_assert_held(&cgrp->pidlist_mutex);
4295
4296         /*
4297          * If cgroup gets more users after we read count, we won't have
4298          * enough space - tough.  This race is indistinguishable to the
4299          * caller from the case that the additional cgroup users didn't
4300          * show up until sometime later on.
4301          */
4302         length = cgroup_task_count(cgrp);
4303         array = pidlist_allocate(length);
4304         if (!array)
4305                 return -ENOMEM;
4306         /* now, populate the array */
4307         css_task_iter_start(&cgrp->self, &it);
4308         while ((tsk = css_task_iter_next(&it))) {
4309                 if (unlikely(n == length))
4310                         break;
4311                 /* get tgid or pid for procs or tasks file respectively */
4312                 if (type == CGROUP_FILE_PROCS)
4313                         pid = task_tgid_vnr(tsk);
4314                 else
4315                         pid = task_pid_vnr(tsk);
4316                 if (pid > 0) /* make sure to only use valid results */
4317                         array[n++] = pid;
4318         }
4319         css_task_iter_end(&it);
4320         length = n;
4321         /* now sort & (if procs) strip out duplicates */
4322         if (cgroup_on_dfl(cgrp))
4323                 sort(array, length, sizeof(pid_t), fried_cmppid, NULL);
4324         else
4325                 sort(array, length, sizeof(pid_t), cmppid, NULL);
4326         if (type == CGROUP_FILE_PROCS)
4327                 length = pidlist_uniq(array, length);
4328
4329         l = cgroup_pidlist_find_create(cgrp, type);
4330         if (!l) {
4331                 pidlist_free(array);
4332                 return -ENOMEM;
4333         }
4334
4335         /* store array, freeing old if necessary */
4336         pidlist_free(l->list);
4337         l->list = array;
4338         l->length = length;
4339         *lp = l;
4340         return 0;
4341 }
4342
4343 /**
4344  * cgroupstats_build - build and fill cgroupstats
4345  * @stats: cgroupstats to fill information into
4346  * @dentry: A dentry entry belonging to the cgroup for which stats have
4347  * been requested.
4348  *
4349  * Build and fill cgroupstats so that taskstats can export it to user
4350  * space.
4351  */
4352 int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry)
4353 {
4354         struct kernfs_node *kn = kernfs_node_from_dentry(dentry);
4355         struct cgroup *cgrp;
4356         struct css_task_iter it;
4357         struct task_struct *tsk;
4358
4359         /* it should be kernfs_node belonging to cgroupfs and is a directory */
4360         if (dentry->d_sb->s_type != &cgroup_fs_type || !kn ||
4361             kernfs_type(kn) != KERNFS_DIR)
4362                 return -EINVAL;
4363
4364         mutex_lock(&cgroup_mutex);
4365
4366         /*
4367          * We aren't being called from kernfs and there's no guarantee on
4368          * @kn->priv's validity.  For this and css_tryget_online_from_dir(),
4369          * @kn->priv is RCU safe.  Let's do the RCU dancing.
4370          */
4371         rcu_read_lock();
4372         cgrp = rcu_dereference(kn->priv);
4373         if (!cgrp || cgroup_is_dead(cgrp)) {
4374                 rcu_read_unlock();
4375                 mutex_unlock(&cgroup_mutex);
4376                 return -ENOENT;
4377         }
4378         rcu_read_unlock();
4379
4380         css_task_iter_start(&cgrp->self, &it);
4381         while ((tsk = css_task_iter_next(&it))) {
4382                 switch (tsk->state) {
4383                 case TASK_RUNNING:
4384                         stats->nr_running++;
4385                         break;
4386                 case TASK_INTERRUPTIBLE:
4387                         stats->nr_sleeping++;
4388                         break;
4389                 case TASK_UNINTERRUPTIBLE:
4390                         stats->nr_uninterruptible++;
4391                         break;
4392                 case TASK_STOPPED:
4393                         stats->nr_stopped++;
4394                         break;
4395                 default:
4396                         if (delayacct_is_task_waiting_on_io(tsk))
4397                                 stats->nr_io_wait++;
4398                         break;
4399                 }
4400         }
4401         css_task_iter_end(&it);
4402
4403         mutex_unlock(&cgroup_mutex);
4404         return 0;
4405 }
4406
4407
4408 /*
4409  * seq_file methods for the tasks/procs files. The seq_file position is the
4410  * next pid to display; the seq_file iterator is a pointer to the pid
4411  * in the cgroup->l->list array.
4412  */
4413
4414 static void *cgroup_pidlist_start(struct seq_file *s, loff_t *pos)
4415 {
4416         /*
4417          * Initially we receive a position value that corresponds to
4418          * one more than the last pid shown (or 0 on the first call or
4419          * after a seek to the start). Use a binary-search to find the
4420          * next pid to display, if any
4421          */
4422         struct kernfs_open_file *of = s->private;
4423         struct cgroup *cgrp = seq_css(s)->cgroup;
4424         struct cgroup_pidlist *l;
4425         enum cgroup_filetype type = seq_cft(s)->private;
4426         int index = 0, pid = *pos;
4427         int *iter, ret;
4428
4429         mutex_lock(&cgrp->pidlist_mutex);
4430
4431         /*
4432          * !NULL @of->priv indicates that this isn't the first start()
4433          * after open.  If the matching pidlist is around, we can use that.
4434          * Look for it.  Note that @of->priv can't be used directly.  It
4435          * could already have been destroyed.
4436          */
4437         if (of->priv)
4438                 of->priv = cgroup_pidlist_find(cgrp, type);
4439
4440         /*
4441          * Either this is the first start() after open or the matching
4442          * pidlist has been destroyed inbetween.  Create a new one.
4443          */
4444         if (!of->priv) {
4445                 ret = pidlist_array_load(cgrp, type,
4446                                          (struct cgroup_pidlist **)&of->priv);
4447                 if (ret)
4448                         return ERR_PTR(ret);
4449         }
4450         l = of->priv;
4451
4452         if (pid) {
4453                 int end = l->length;
4454
4455                 while (index < end) {
4456                         int mid = (index + end) / 2;
4457                         if (cgroup_pid_fry(cgrp, l->list[mid]) == pid) {
4458                                 index = mid;
4459                                 break;
4460                         } else if (cgroup_pid_fry(cgrp, l->list[mid]) <= pid)
4461                                 index = mid + 1;
4462                         else
4463                                 end = mid;
4464                 }
4465         }
4466         /* If we're off the end of the array, we're done */
4467         if (index >= l->length)
4468                 return NULL;
4469         /* Update the abstract position to be the actual pid that we found */
4470         iter = l->list + index;
4471         *pos = cgroup_pid_fry(cgrp, *iter);
4472         return iter;
4473 }
4474
4475 static void cgroup_pidlist_stop(struct seq_file *s, void *v)
4476 {
4477         struct kernfs_open_file *of = s->private;
4478         struct cgroup_pidlist *l = of->priv;
4479
4480         if (l)
4481                 mod_delayed_work(cgroup_pidlist_destroy_wq, &l->destroy_dwork,
4482                                  CGROUP_PIDLIST_DESTROY_DELAY);
4483         mutex_unlock(&seq_css(s)->cgroup->pidlist_mutex);
4484 }
4485
4486 static void *cgroup_pidlist_next(struct seq_file *s, void *v, loff_t *pos)
4487 {
4488         struct kernfs_open_file *of = s->private;
4489         struct cgroup_pidlist *l = of->priv;
4490         pid_t *p = v;
4491         pid_t *end = l->list + l->length;
4492         /*
4493          * Advance to the next pid in the array. If this goes off the
4494          * end, we're done
4495          */
4496         p++;
4497         if (p >= end) {
4498                 return NULL;
4499         } else {
4500                 *pos = cgroup_pid_fry(seq_css(s)->cgroup, *p);
4501                 return p;
4502         }
4503 }
4504
4505 static int cgroup_pidlist_show(struct seq_file *s, void *v)
4506 {
4507         seq_printf(s, "%d\n", *(int *)v);
4508
4509         return 0;
4510 }
4511
4512 static u64 cgroup_read_notify_on_release(struct cgroup_subsys_state *css,
4513                                          struct cftype *cft)
4514 {
4515         return notify_on_release(css->cgroup);
4516 }
4517
4518 static int cgroup_write_notify_on_release(struct cgroup_subsys_state *css,
4519                                           struct cftype *cft, u64 val)
4520 {
4521         if (val)
4522                 set_bit(CGRP_NOTIFY_ON_RELEASE, &css->cgroup->flags);
4523         else
4524                 clear_bit(CGRP_NOTIFY_ON_RELEASE, &css->cgroup->flags);
4525         return 0;
4526 }
4527
4528 static u64 cgroup_clone_children_read(struct cgroup_subsys_state *css,
4529                                       struct cftype *cft)
4530 {
4531         return test_bit(CGRP_CPUSET_CLONE_CHILDREN, &css->cgroup->flags);
4532 }
4533
4534 static int cgroup_clone_children_write(struct cgroup_subsys_state *css,
4535                                        struct cftype *cft, u64 val)
4536 {
4537         if (val)
4538                 set_bit(CGRP_CPUSET_CLONE_CHILDREN, &css->cgroup->flags);
4539         else
4540                 clear_bit(CGRP_CPUSET_CLONE_CHILDREN, &css->cgroup->flags);
4541         return 0;
4542 }
4543
4544 /* cgroup core interface files for the default hierarchy */
4545 static struct cftype cgroup_dfl_base_files[] = {
4546         {
4547                 .name = "cgroup.procs",
4548                 .file_offset = offsetof(struct cgroup, procs_file),
4549                 .seq_start = cgroup_pidlist_start,
4550                 .seq_next = cgroup_pidlist_next,
4551                 .seq_stop = cgroup_pidlist_stop,
4552                 .seq_show = cgroup_pidlist_show,
4553                 .private = CGROUP_FILE_PROCS,
4554                 .write = cgroup_procs_write,
4555         },
4556         {
4557                 .name = "cgroup.controllers",
4558                 .flags = CFTYPE_ONLY_ON_ROOT,
4559                 .seq_show = cgroup_root_controllers_show,
4560         },
4561         {
4562                 .name = "cgroup.controllers",
4563                 .flags = CFTYPE_NOT_ON_ROOT,
4564                 .seq_show = cgroup_controllers_show,
4565         },
4566         {
4567                 .name = "cgroup.subtree_control",
4568                 .seq_show = cgroup_subtree_control_show,
4569                 .write = cgroup_subtree_control_write,
4570         },
4571         {
4572                 .name = "cgroup.events",
4573                 .flags = CFTYPE_NOT_ON_ROOT,
4574                 .file_offset = offsetof(struct cgroup, events_file),
4575                 .seq_show = cgroup_events_show,
4576         },
4577         { }     /* terminate */
4578 };
4579
4580 /* cgroup core interface files for the legacy hierarchies */
4581 static struct cftype cgroup_legacy_base_files[] = {
4582         {
4583                 .name = "cgroup.procs",
4584                 .seq_start = cgroup_pidlist_start,
4585                 .seq_next = cgroup_pidlist_next,
4586                 .seq_stop = cgroup_pidlist_stop,
4587                 .seq_show = cgroup_pidlist_show,
4588                 .private = CGROUP_FILE_PROCS,
4589                 .write = cgroup_procs_write,
4590         },
4591         {
4592                 .name = "cgroup.clone_children",
4593                 .read_u64 = cgroup_clone_children_read,
4594                 .write_u64 = cgroup_clone_children_write,
4595         },
4596         {
4597                 .name = "cgroup.sane_behavior",
4598                 .flags = CFTYPE_ONLY_ON_ROOT,
4599                 .seq_show = cgroup_sane_behavior_show,
4600         },
4601         {
4602                 .name = "tasks",
4603                 .seq_start = cgroup_pidlist_start,
4604                 .seq_next = cgroup_pidlist_next,
4605                 .seq_stop = cgroup_pidlist_stop,
4606                 .seq_show = cgroup_pidlist_show,
4607                 .private = CGROUP_FILE_TASKS,
4608                 .write = cgroup_tasks_write,
4609         },
4610         {
4611                 .name = "notify_on_release",
4612                 .read_u64 = cgroup_read_notify_on_release,
4613                 .write_u64 = cgroup_write_notify_on_release,
4614         },
4615         {
4616                 .name = "release_agent",
4617                 .flags = CFTYPE_ONLY_ON_ROOT,
4618                 .seq_show = cgroup_release_agent_show,
4619                 .write = cgroup_release_agent_write,
4620                 .max_write_len = PATH_MAX - 1,
4621         },
4622         { }     /* terminate */
4623 };
4624
4625 /*
4626  * css destruction is four-stage process.
4627  *
4628  * 1. Destruction starts.  Killing of the percpu_ref is initiated.
4629  *    Implemented in kill_css().
4630  *
4631  * 2. When the percpu_ref is confirmed to be visible as killed on all CPUs
4632  *    and thus css_tryget_online() is guaranteed to fail, the css can be
4633  *    offlined by invoking offline_css().  After offlining, the base ref is
4634  *    put.  Implemented in css_killed_work_fn().
4635  *
4636  * 3. When the percpu_ref reaches zero, the only possible remaining
4637  *    accessors are inside RCU read sections.  css_release() schedules the
4638  *    RCU callback.
4639  *
4640  * 4. After the grace period, the css can be freed.  Implemented in
4641  *    css_free_work_fn().
4642  *
4643  * It is actually hairier because both step 2 and 4 require process context
4644  * and thus involve punting to css->destroy_work adding two additional
4645  * steps to the already complex sequence.
4646  */
4647 static void css_free_work_fn(struct work_struct *work)
4648 {
4649         struct cgroup_subsys_state *css =
4650                 container_of(work, struct cgroup_subsys_state, destroy_work);
4651         struct cgroup_subsys *ss = css->ss;
4652         struct cgroup *cgrp = css->cgroup;
4653
4654         percpu_ref_exit(&css->refcnt);
4655
4656         if (ss) {
4657                 /* css free path */
4658                 int id = css->id;
4659
4660                 if (css->parent)
4661                         css_put(css->parent);
4662
4663                 ss->css_free(css);
4664                 cgroup_idr_remove(&ss->css_idr, id);
4665                 cgroup_put(cgrp);
4666         } else {
4667                 /* cgroup free path */
4668                 atomic_dec(&cgrp->root->nr_cgrps);
4669                 cgroup_pidlist_destroy_all(cgrp);
4670                 cancel_work_sync(&cgrp->release_agent_work);
4671
4672                 if (cgroup_parent(cgrp)) {
4673                         /*
4674                          * We get a ref to the parent, and put the ref when
4675                          * this cgroup is being freed, so it's guaranteed
4676                          * that the parent won't be destroyed before its
4677                          * children.
4678                          */
4679                         cgroup_put(cgroup_parent(cgrp));
4680                         kernfs_put(cgrp->kn);
4681                         kfree(cgrp);
4682                 } else {
4683                         /*
4684                          * This is root cgroup's refcnt reaching zero,
4685                          * which indicates that the root should be
4686                          * released.
4687                          */
4688                         cgroup_destroy_root(cgrp->root);
4689                 }
4690         }
4691 }
4692
4693 static void css_free_rcu_fn(struct rcu_head *rcu_head)
4694 {
4695         struct cgroup_subsys_state *css =
4696                 container_of(rcu_head, struct cgroup_subsys_state, rcu_head);
4697
4698         INIT_WORK(&css->destroy_work, css_free_work_fn);
4699         queue_work(cgroup_destroy_wq, &css->destroy_work);
4700 }
4701
4702 static void css_release_work_fn(struct work_struct *work)
4703 {
4704         struct cgroup_subsys_state *css =
4705                 container_of(work, struct cgroup_subsys_state, destroy_work);
4706         struct cgroup_subsys *ss = css->ss;
4707         struct cgroup *cgrp = css->cgroup;
4708
4709         mutex_lock(&cgroup_mutex);
4710
4711         css->flags |= CSS_RELEASED;
4712         list_del_rcu(&css->sibling);
4713
4714         if (ss) {
4715                 /* css release path */
4716                 cgroup_idr_replace(&ss->css_idr, NULL, css->id);
4717                 if (ss->css_released)
4718                         ss->css_released(css);
4719         } else {
4720                 /* cgroup release path */
4721                 cgroup_idr_remove(&cgrp->root->cgroup_idr, cgrp->id);
4722                 cgrp->id = -1;
4723
4724                 /*
4725                  * There are two control paths which try to determine
4726                  * cgroup from dentry without going through kernfs -
4727                  * cgroupstats_build() and css_tryget_online_from_dir().
4728                  * Those are supported by RCU protecting clearing of
4729                  * cgrp->kn->priv backpointer.
4730                  */
4731                 RCU_INIT_POINTER(*(void __rcu __force **)&cgrp->kn->priv, NULL);
4732         }
4733
4734         mutex_unlock(&cgroup_mutex);
4735
4736         call_rcu(&css->rcu_head, css_free_rcu_fn);
4737 }
4738
4739 static void css_release(struct percpu_ref *ref)
4740 {
4741         struct cgroup_subsys_state *css =
4742                 container_of(ref, struct cgroup_subsys_state, refcnt);
4743
4744         INIT_WORK(&css->destroy_work, css_release_work_fn);
4745         queue_work(cgroup_destroy_wq, &css->destroy_work);
4746 }
4747
4748 static void init_and_link_css(struct cgroup_subsys_state *css,
4749                               struct cgroup_subsys *ss, struct cgroup *cgrp)
4750 {
4751         lockdep_assert_held(&cgroup_mutex);
4752
4753         cgroup_get(cgrp);
4754
4755         memset(css, 0, sizeof(*css));
4756         css->cgroup = cgrp;
4757         css->ss = ss;
4758         INIT_LIST_HEAD(&css->sibling);
4759         INIT_LIST_HEAD(&css->children);
4760         css->serial_nr = css_serial_nr_next++;
4761
4762         if (cgroup_parent(cgrp)) {
4763                 css->parent = cgroup_css(cgroup_parent(cgrp), ss);
4764                 css_get(css->parent);
4765         }
4766
4767         BUG_ON(cgroup_css(cgrp, ss));
4768 }
4769
4770 /* invoke ->css_online() on a new CSS and mark it online if successful */
4771 static int online_css(struct cgroup_subsys_state *css)
4772 {
4773         struct cgroup_subsys *ss = css->ss;
4774         int ret = 0;
4775
4776         lockdep_assert_held(&cgroup_mutex);
4777
4778         if (ss->css_online)
4779                 ret = ss->css_online(css);
4780         if (!ret) {
4781                 css->flags |= CSS_ONLINE;
4782                 rcu_assign_pointer(css->cgroup->subsys[ss->id], css);
4783         }
4784         return ret;
4785 }
4786
4787 /* if the CSS is online, invoke ->css_offline() on it and mark it offline */
4788 static void offline_css(struct cgroup_subsys_state *css)
4789 {
4790         struct cgroup_subsys *ss = css->ss;
4791
4792         lockdep_assert_held(&cgroup_mutex);
4793
4794         if (!(css->flags & CSS_ONLINE))
4795                 return;
4796
4797         if (ss->css_offline)
4798                 ss->css_offline(css);
4799
4800         css->flags &= ~CSS_ONLINE;
4801         RCU_INIT_POINTER(css->cgroup->subsys[ss->id], NULL);
4802
4803         wake_up_all(&css->cgroup->offline_waitq);
4804 }
4805
4806 /**
4807  * create_css - create a cgroup_subsys_state
4808  * @cgrp: the cgroup new css will be associated with
4809  * @ss: the subsys of new css
4810  * @visible: whether to create control knobs for the new css or not
4811  *
4812  * Create a new css associated with @cgrp - @ss pair.  On success, the new
4813  * css is online and installed in @cgrp with all interface files created if
4814  * @visible.  Returns 0 on success, -errno on failure.
4815  */
4816 static int create_css(struct cgroup *cgrp, struct cgroup_subsys *ss,
4817                       bool visible)
4818 {
4819         struct cgroup *parent = cgroup_parent(cgrp);
4820         struct cgroup_subsys_state *parent_css = cgroup_css(parent, ss);
4821         struct cgroup_subsys_state *css;
4822         int err;
4823
4824         lockdep_assert_held(&cgroup_mutex);
4825
4826         css = ss->css_alloc(parent_css);
4827         if (IS_ERR(css))
4828                 return PTR_ERR(css);
4829
4830         init_and_link_css(css, ss, cgrp);
4831
4832         err = percpu_ref_init(&css->refcnt, css_release, 0, GFP_KERNEL);
4833         if (err)
4834                 goto err_free_css;
4835
4836         err = cgroup_idr_alloc(&ss->css_idr, NULL, 2, 0, GFP_KERNEL);
4837         if (err < 0)
4838                 goto err_free_percpu_ref;
4839         css->id = err;
4840
4841         if (visible) {
4842                 err = css_populate_dir(css, NULL);
4843                 if (err)
4844                         goto err_free_id;
4845         }
4846
4847         /* @css is ready to be brought online now, make it visible */
4848         list_add_tail_rcu(&css->sibling, &parent_css->children);
4849         cgroup_idr_replace(&ss->css_idr, css, css->id);
4850
4851         err = online_css(css);
4852         if (err)
4853                 goto err_list_del;
4854
4855         if (ss->broken_hierarchy && !ss->warned_broken_hierarchy &&
4856             cgroup_parent(parent)) {
4857                 pr_warn("%s (%d) created nested cgroup for controller \"%s\" which has incomplete hierarchy support. Nested cgroups may change behavior in the future.\n",
4858                         current->comm, current->pid, ss->name);
4859                 if (!strcmp(ss->name, "memory"))
4860                         pr_warn("\"memory\" requires setting use_hierarchy to 1 on the root\n");
4861                 ss->warned_broken_hierarchy = true;
4862         }
4863
4864         return 0;
4865
4866 err_list_del:
4867         list_del_rcu(&css->sibling);
4868         css_clear_dir(css, NULL);
4869 err_free_id:
4870         cgroup_idr_remove(&ss->css_idr, css->id);
4871 err_free_percpu_ref:
4872         percpu_ref_exit(&css->refcnt);
4873 err_free_css:
4874         call_rcu(&css->rcu_head, css_free_rcu_fn);
4875         return err;
4876 }
4877
4878 static int cgroup_mkdir(struct kernfs_node *parent_kn, const char *name,
4879                         umode_t mode)
4880 {
4881         struct cgroup *parent, *cgrp, *tcgrp;
4882         struct cgroup_root *root;
4883         struct cgroup_subsys *ss;
4884         struct kernfs_node *kn;
4885         int level, ssid, ret;
4886
4887         /* Do not accept '\n' to prevent making /proc/<pid>/cgroup unparsable.
4888          */
4889         if (strchr(name, '\n'))
4890                 return -EINVAL;
4891
4892         parent = cgroup_kn_lock_live(parent_kn);
4893         if (!parent)
4894                 return -ENODEV;
4895         root = parent->root;
4896         level = parent->level + 1;
4897
4898         /* allocate the cgroup and its ID, 0 is reserved for the root */
4899         cgrp = kzalloc(sizeof(*cgrp) +
4900                        sizeof(cgrp->ancestor_ids[0]) * (level + 1), GFP_KERNEL);
4901         if (!cgrp) {
4902                 ret = -ENOMEM;
4903                 goto out_unlock;
4904         }
4905
4906         ret = percpu_ref_init(&cgrp->self.refcnt, css_release, 0, GFP_KERNEL);
4907         if (ret)
4908                 goto out_free_cgrp;
4909
4910         /*
4911          * Temporarily set the pointer to NULL, so idr_find() won't return
4912          * a half-baked cgroup.
4913          */
4914         cgrp->id = cgroup_idr_alloc(&root->cgroup_idr, NULL, 2, 0, GFP_KERNEL);
4915         if (cgrp->id < 0) {
4916                 ret = -ENOMEM;
4917                 goto out_cancel_ref;
4918         }
4919
4920         init_cgroup_housekeeping(cgrp);
4921
4922         cgrp->self.parent = &parent->self;
4923         cgrp->root = root;
4924         cgrp->level = level;
4925
4926         for (tcgrp = cgrp; tcgrp; tcgrp = cgroup_parent(tcgrp))
4927                 cgrp->ancestor_ids[tcgrp->level] = tcgrp->id;
4928
4929         if (notify_on_release(parent))
4930                 set_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);
4931
4932         if (test_bit(CGRP_CPUSET_CLONE_CHILDREN, &parent->flags))
4933                 set_bit(CGRP_CPUSET_CLONE_CHILDREN, &cgrp->flags);
4934
4935         /* create the directory */
4936         kn = kernfs_create_dir(parent->kn, name, mode, cgrp);
4937         if (IS_ERR(kn)) {
4938                 ret = PTR_ERR(kn);
4939                 goto out_free_id;
4940         }
4941         cgrp->kn = kn;
4942
4943         /*
4944          * This extra ref will be put in cgroup_free_fn() and guarantees
4945          * that @cgrp->kn is always accessible.
4946          */
4947         kernfs_get(kn);
4948
4949         cgrp->self.serial_nr = css_serial_nr_next++;
4950
4951         /* allocation complete, commit to creation */
4952         list_add_tail_rcu(&cgrp->self.sibling, &cgroup_parent(cgrp)->self.children);
4953         atomic_inc(&root->nr_cgrps);
4954         cgroup_get(parent);
4955
4956         /*
4957          * @cgrp is now fully operational.  If something fails after this
4958          * point, it'll be released via the normal destruction path.
4959          */
4960         cgroup_idr_replace(&root->cgroup_idr, cgrp, cgrp->id);
4961
4962         ret = cgroup_kn_set_ugid(kn);
4963         if (ret)
4964                 goto out_destroy;
4965
4966         ret = css_populate_dir(&cgrp->self, NULL);
4967         if (ret)
4968                 goto out_destroy;
4969
4970         /* let's create and online css's */
4971         for_each_subsys(ss, ssid) {
4972                 if (parent->child_subsys_mask & (1 << ssid)) {
4973                         ret = create_css(cgrp, ss,
4974                                          parent->subtree_control & (1 << ssid));
4975                         if (ret)
4976                                 goto out_destroy;
4977                 }
4978         }
4979
4980         /*
4981          * On the default hierarchy, a child doesn't automatically inherit
4982          * subtree_control from the parent.  Each is configured manually.
4983          */
4984         if (!cgroup_on_dfl(cgrp)) {
4985                 cgrp->subtree_control = parent->subtree_control;
4986                 cgroup_refresh_child_subsys_mask(cgrp);
4987         }
4988
4989         kernfs_activate(kn);
4990
4991         ret = 0;
4992         goto out_unlock;
4993
4994 out_free_id:
4995         cgroup_idr_remove(&root->cgroup_idr, cgrp->id);
4996 out_cancel_ref:
4997         percpu_ref_exit(&cgrp->self.refcnt);
4998 out_free_cgrp:
4999         kfree(cgrp);
5000 out_unlock:
5001         cgroup_kn_unlock(parent_kn);
5002         return ret;
5003
5004 out_destroy:
5005         cgroup_destroy_locked(cgrp);
5006         goto out_unlock;
5007 }
5008
5009 /*
5010  * This is called when the refcnt of a css is confirmed to be killed.
5011  * css_tryget_online() is now guaranteed to fail.  Tell the subsystem to
5012  * initate destruction and put the css ref from kill_css().
5013  */
5014 static void css_killed_work_fn(struct work_struct *work)
5015 {
5016         struct cgroup_subsys_state *css =
5017                 container_of(work, struct cgroup_subsys_state, destroy_work);
5018
5019         mutex_lock(&cgroup_mutex);
5020         offline_css(css);
5021         mutex_unlock(&cgroup_mutex);
5022
5023         css_put(css);
5024 }
5025
5026 /* css kill confirmation processing requires process context, bounce */
5027 static void css_killed_ref_fn(struct percpu_ref *ref)
5028 {
5029         struct cgroup_subsys_state *css =
5030                 container_of(ref, struct cgroup_subsys_state, refcnt);
5031
5032         INIT_WORK(&css->destroy_work, css_killed_work_fn);
5033         queue_work(cgroup_destroy_wq, &css->destroy_work);
5034 }
5035
5036 /**
5037  * kill_css - destroy a css
5038  * @css: css to destroy
5039  *
5040  * This function initiates destruction of @css by removing cgroup interface
5041  * files and putting its base reference.  ->css_offline() will be invoked
5042  * asynchronously once css_tryget_online() is guaranteed to fail and when
5043  * the reference count reaches zero, @css will be released.
5044  */
5045 static void kill_css(struct cgroup_subsys_state *css)
5046 {
5047         lockdep_assert_held(&cgroup_mutex);
5048
5049         /*
5050          * This must happen before css is disassociated with its cgroup.
5051          * See seq_css() for details.
5052          */
5053         css_clear_dir(css, NULL);
5054
5055         /*
5056          * Killing would put the base ref, but we need to keep it alive
5057          * until after ->css_offline().
5058          */
5059         css_get(css);
5060
5061         /*
5062          * cgroup core guarantees that, by the time ->css_offline() is
5063          * invoked, no new css reference will be given out via
5064          * css_tryget_online().  We can't simply call percpu_ref_kill() and
5065          * proceed to offlining css's because percpu_ref_kill() doesn't
5066          * guarantee that the ref is seen as killed on all CPUs on return.
5067          *
5068          * Use percpu_ref_kill_and_confirm() to get notifications as each
5069          * css is confirmed to be seen as killed on all CPUs.
5070          */
5071         percpu_ref_kill_and_confirm(&css->refcnt, css_killed_ref_fn);
5072 }
5073
5074 /**
5075  * cgroup_destroy_locked - the first stage of cgroup destruction
5076  * @cgrp: cgroup to be destroyed
5077  *
5078  * css's make use of percpu refcnts whose killing latency shouldn't be
5079  * exposed to userland and are RCU protected.  Also, cgroup core needs to
5080  * guarantee that css_tryget_online() won't succeed by the time
5081  * ->css_offline() is invoked.  To satisfy all the requirements,
5082  * destruction is implemented in the following two steps.
5083  *
5084  * s1. Verify @cgrp can be destroyed and mark it dying.  Remove all
5085  *     userland visible parts and start killing the percpu refcnts of
5086  *     css's.  Set up so that the next stage will be kicked off once all
5087  *     the percpu refcnts are confirmed to be killed.
5088  *
5089  * s2. Invoke ->css_offline(), mark the cgroup dead and proceed with the
5090  *     rest of destruction.  Once all cgroup references are gone, the
5091  *     cgroup is RCU-freed.
5092  *
5093  * This function implements s1.  After this step, @cgrp is gone as far as
5094  * the userland is concerned and a new cgroup with the same name may be
5095  * created.  As cgroup doesn't care about the names internally, this
5096  * doesn't cause any problem.
5097  */
5098 static int cgroup_destroy_locked(struct cgroup *cgrp)
5099         __releases(&cgroup_mutex) __acquires(&cgroup_mutex)
5100 {
5101         struct cgroup_subsys_state *css;
5102         int ssid;
5103
5104         lockdep_assert_held(&cgroup_mutex);
5105
5106         /*
5107          * Only migration can raise populated from zero and we're already
5108          * holding cgroup_mutex.
5109          */
5110         if (cgroup_is_populated(cgrp))
5111                 return -EBUSY;
5112
5113         /*
5114          * Make sure there's no live children.  We can't test emptiness of
5115          * ->self.children as dead children linger on it while being
5116          * drained; otherwise, "rmdir parent/child parent" may fail.
5117          */
5118         if (css_has_online_children(&cgrp->self))
5119                 return -EBUSY;
5120
5121         /*
5122          * Mark @cgrp dead.  This prevents further task migration and child
5123          * creation by disabling cgroup_lock_live_group().
5124          */
5125         cgrp->self.flags &= ~CSS_ONLINE;
5126
5127         /* initiate massacre of all css's */
5128         for_each_css(css, ssid, cgrp)
5129                 kill_css(css);
5130
5131         /*
5132          * Remove @cgrp directory along with the base files.  @cgrp has an
5133          * extra ref on its kn.
5134          */
5135         kernfs_remove(cgrp->kn);
5136
5137         check_for_release(cgroup_parent(cgrp));
5138
5139         /* put the base reference */
5140         percpu_ref_kill(&cgrp->self.refcnt);
5141
5142         return 0;
5143 };
5144
5145 static int cgroup_rmdir(struct kernfs_node *kn)
5146 {
5147         struct cgroup *cgrp;
5148         int ret = 0;
5149
5150         cgrp = cgroup_kn_lock_live(kn);
5151         if (!cgrp)
5152                 return 0;
5153
5154         ret = cgroup_destroy_locked(cgrp);
5155
5156         cgroup_kn_unlock(kn);
5157         return ret;
5158 }
5159
5160 static struct kernfs_syscall_ops cgroup_kf_syscall_ops = {
5161         .remount_fs             = cgroup_remount,
5162         .show_options           = cgroup_show_options,
5163         .mkdir                  = cgroup_mkdir,
5164         .rmdir                  = cgroup_rmdir,
5165         .rename                 = cgroup_rename,
5166 };
5167
5168 static void __init cgroup_init_subsys(struct cgroup_subsys *ss, bool early)
5169 {
5170         struct cgroup_subsys_state *css;
5171
5172         pr_debug("Initializing cgroup subsys %s\n", ss->name);
5173
5174         mutex_lock(&cgroup_mutex);
5175
5176         idr_init(&ss->css_idr);
5177         INIT_LIST_HEAD(&ss->cfts);
5178
5179         /* Create the root cgroup state for this subsystem */
5180         ss->root = &cgrp_dfl_root;
5181         css = ss->css_alloc(cgroup_css(&cgrp_dfl_root.cgrp, ss));
5182         /* We don't handle early failures gracefully */
5183         BUG_ON(IS_ERR(css));
5184         init_and_link_css(css, ss, &cgrp_dfl_root.cgrp);
5185
5186         /*
5187          * Root csses are never destroyed and we can't initialize
5188          * percpu_ref during early init.  Disable refcnting.
5189          */
5190         css->flags |= CSS_NO_REF;
5191
5192         if (early) {
5193                 /* allocation can't be done safely during early init */
5194                 css->id = 1;
5195         } else {
5196                 css->id = cgroup_idr_alloc(&ss->css_idr, css, 1, 2, GFP_KERNEL);
5197                 BUG_ON(css->id < 0);
5198         }
5199
5200         /* Update the init_css_set to contain a subsys
5201          * pointer to this state - since the subsystem is
5202          * newly registered, all tasks and hence the
5203          * init_css_set is in the subsystem's root cgroup. */
5204         init_css_set.subsys[ss->id] = css;
5205
5206         have_fork_callback |= (bool)ss->fork << ss->id;
5207         have_exit_callback |= (bool)ss->exit << ss->id;
5208         have_free_callback |= (bool)ss->free << ss->id;
5209         have_canfork_callback |= (bool)ss->can_fork << ss->id;
5210
5211         /* At system boot, before all subsystems have been
5212          * registered, no tasks have been forked, so we don't
5213          * need to invoke fork callbacks here. */
5214         BUG_ON(!list_empty(&init_task.tasks));
5215
5216         BUG_ON(online_css(css));
5217
5218         mutex_unlock(&cgroup_mutex);
5219 }
5220
5221 /**
5222  * cgroup_init_early - cgroup initialization at system boot
5223  *
5224  * Initialize cgroups at system boot, and initialize any
5225  * subsystems that request early init.
5226  */
5227 int __init cgroup_init_early(void)
5228 {
5229         static struct cgroup_sb_opts __initdata opts;
5230         struct cgroup_subsys *ss;
5231         int i;
5232
5233         init_cgroup_root(&cgrp_dfl_root, &opts);
5234         cgrp_dfl_root.cgrp.self.flags |= CSS_NO_REF;
5235
5236         RCU_INIT_POINTER(init_task.cgroups, &init_css_set);
5237
5238         for_each_subsys(ss, i) {
5239                 WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id,
5240                      "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p name:id=%d:%s\n",
5241                      i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free,
5242                      ss->id, ss->name);
5243                 WARN(strlen(cgroup_subsys_name[i]) > MAX_CGROUP_TYPE_NAMELEN,
5244                      "cgroup_subsys_name %s too long\n", cgroup_subsys_name[i]);
5245
5246                 ss->id = i;
5247                 ss->name = cgroup_subsys_name[i];
5248                 if (!ss->legacy_name)
5249                         ss->legacy_name = cgroup_subsys_name[i];
5250
5251                 if (ss->early_init)
5252                         cgroup_init_subsys(ss, true);
5253         }
5254         return 0;
5255 }
5256
5257 static unsigned long cgroup_disable_mask __initdata;
5258
5259 /**
5260  * cgroup_init - cgroup initialization
5261  *
5262  * Register cgroup filesystem and /proc file, and initialize
5263  * any subsystems that didn't request early init.
5264  */
5265 int __init cgroup_init(void)
5266 {
5267         struct cgroup_subsys *ss;
5268         unsigned long key;
5269         int ssid;
5270
5271         BUG_ON(percpu_init_rwsem(&cgroup_threadgroup_rwsem));
5272         BUG_ON(cgroup_init_cftypes(NULL, cgroup_dfl_base_files));
5273         BUG_ON(cgroup_init_cftypes(NULL, cgroup_legacy_base_files));
5274
5275         mutex_lock(&cgroup_mutex);
5276
5277         /* Add init_css_set to the hash table */
5278         key = css_set_hash(init_css_set.subsys);
5279         hash_add(css_set_table, &init_css_set.hlist, key);
5280
5281         BUG_ON(cgroup_setup_root(&cgrp_dfl_root, 0));
5282
5283         mutex_unlock(&cgroup_mutex);
5284
5285         for_each_subsys(ss, ssid) {
5286                 if (ss->early_init) {
5287                         struct cgroup_subsys_state *css =
5288                                 init_css_set.subsys[ss->id];
5289
5290                         css->id = cgroup_idr_alloc(&ss->css_idr, css, 1, 2,
5291                                                    GFP_KERNEL);
5292                         BUG_ON(css->id < 0);
5293                 } else {
5294                         cgroup_init_subsys(ss, false);
5295                 }
5296
5297                 list_add_tail(&init_css_set.e_cset_node[ssid],
5298                               &cgrp_dfl_root.cgrp.e_csets[ssid]);
5299
5300                 /*
5301                  * Setting dfl_root subsys_mask needs to consider the
5302                  * disabled flag and cftype registration needs kmalloc,
5303                  * both of which aren't available during early_init.
5304                  */
5305                 if (cgroup_disable_mask & (1 << ssid)) {
5306                         static_branch_disable(cgroup_subsys_enabled_key[ssid]);
5307                         printk(KERN_INFO "Disabling %s control group subsystem\n",
5308                                ss->name);
5309                         continue;
5310                 }
5311
5312                 cgrp_dfl_root.subsys_mask |= 1 << ss->id;
5313
5314                 if (!ss->dfl_cftypes)
5315                         cgrp_dfl_root_inhibit_ss_mask |= 1 << ss->id;
5316
5317                 if (ss->dfl_cftypes == ss->legacy_cftypes) {
5318                         WARN_ON(cgroup_add_cftypes(ss, ss->dfl_cftypes));
5319                 } else {
5320                         WARN_ON(cgroup_add_dfl_cftypes(ss, ss->dfl_cftypes));
5321                         WARN_ON(cgroup_add_legacy_cftypes(ss, ss->legacy_cftypes));
5322                 }
5323
5324                 if (ss->bind)
5325                         ss->bind(init_css_set.subsys[ssid]);
5326         }
5327
5328         WARN_ON(sysfs_create_mount_point(fs_kobj, "cgroup"));
5329         WARN_ON(register_filesystem(&cgroup_fs_type));
5330         WARN_ON(register_filesystem(&cgroup2_fs_type));
5331         WARN_ON(!proc_create("cgroups", 0, NULL, &proc_cgroupstats_operations));
5332
5333         return 0;
5334 }
5335
5336 static int __init cgroup_wq_init(void)
5337 {
5338         /*
5339          * There isn't much point in executing destruction path in
5340          * parallel.  Good chunk is serialized with cgroup_mutex anyway.
5341          * Use 1 for @max_active.
5342          *
5343          * We would prefer to do this in cgroup_init() above, but that
5344          * is called before init_workqueues(): so leave this until after.
5345          */
5346         cgroup_destroy_wq = alloc_workqueue("cgroup_destroy", 0, 1);
5347         BUG_ON(!cgroup_destroy_wq);
5348
5349         /*
5350          * Used to destroy pidlists and separate to serve as flush domain.
5351          * Cap @max_active to 1 too.
5352          */
5353         cgroup_pidlist_destroy_wq = alloc_workqueue("cgroup_pidlist_destroy",
5354                                                     0, 1);
5355         BUG_ON(!cgroup_pidlist_destroy_wq);
5356
5357         return 0;
5358 }
5359 core_initcall(cgroup_wq_init);
5360
5361 /*
5362  * proc_cgroup_show()
5363  *  - Print task's cgroup paths into seq_file, one line for each hierarchy
5364  *  - Used for /proc/<pid>/cgroup.
5365  */
5366 int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
5367                      struct pid *pid, struct task_struct *tsk)
5368 {
5369         char *buf, *path;
5370         int retval;
5371         struct cgroup_root *root;
5372
5373         retval = -ENOMEM;
5374         buf = kmalloc(PATH_MAX, GFP_KERNEL);
5375         if (!buf)
5376                 goto out;
5377
5378         mutex_lock(&cgroup_mutex);
5379         spin_lock_bh(&css_set_lock);
5380
5381         for_each_root(root) {
5382                 struct cgroup_subsys *ss;
5383                 struct cgroup *cgrp;
5384                 int ssid, count = 0;
5385
5386                 if (root == &cgrp_dfl_root && !cgrp_dfl_root_visible)
5387                         continue;
5388
5389                 seq_printf(m, "%d:", root->hierarchy_id);
5390                 if (root != &cgrp_dfl_root)
5391                         for_each_subsys(ss, ssid)
5392                                 if (root->subsys_mask & (1 << ssid))
5393                                         seq_printf(m, "%s%s", count++ ? "," : "",
5394                                                    ss->legacy_name);
5395                 if (strlen(root->name))
5396                         seq_printf(m, "%sname=%s", count ? "," : "",
5397                                    root->name);
5398                 seq_putc(m, ':');
5399
5400                 cgrp = task_cgroup_from_root(tsk, root);
5401
5402                 /*
5403                  * On traditional hierarchies, all zombie tasks show up as
5404                  * belonging to the root cgroup.  On the default hierarchy,
5405                  * while a zombie doesn't show up in "cgroup.procs" and
5406                  * thus can't be migrated, its /proc/PID/cgroup keeps
5407                  * reporting the cgroup it belonged to before exiting.  If
5408                  * the cgroup is removed before the zombie is reaped,
5409                  * " (deleted)" is appended to the cgroup path.
5410                  */
5411                 if (cgroup_on_dfl(cgrp) || !(tsk->flags & PF_EXITING)) {
5412                         path = cgroup_path(cgrp, buf, PATH_MAX);
5413                         if (!path) {
5414                                 retval = -ENAMETOOLONG;
5415                                 goto out_unlock;
5416                         }
5417                 } else {
5418                         path = "/";
5419                 }
5420
5421                 seq_puts(m, path);
5422
5423                 if (cgroup_on_dfl(cgrp) && cgroup_is_dead(cgrp))
5424                         seq_puts(m, " (deleted)\n");
5425                 else
5426                         seq_putc(m, '\n');
5427         }
5428
5429         retval = 0;
5430 out_unlock:
5431         spin_unlock_bh(&css_set_lock);
5432         mutex_unlock(&cgroup_mutex);
5433         kfree(buf);
5434 out:
5435         return retval;
5436 }
5437
5438 /* Display information about each subsystem and each hierarchy */
5439 static int proc_cgroupstats_show(struct seq_file *m, void *v)
5440 {
5441         struct cgroup_subsys *ss;
5442         int i;
5443
5444         seq_puts(m, "#subsys_name\thierarchy\tnum_cgroups\tenabled\n");
5445         /*
5446          * ideally we don't want subsystems moving around while we do this.
5447          * cgroup_mutex is also necessary to guarantee an atomic snapshot of
5448          * subsys/hierarchy state.
5449          */
5450         mutex_lock(&cgroup_mutex);
5451
5452         for_each_subsys(ss, i)
5453                 seq_printf(m, "%s\t%d\t%d\t%d\n",
5454                            ss->legacy_name, ss->root->hierarchy_id,
5455                            atomic_read(&ss->root->nr_cgrps),
5456                            cgroup_ssid_enabled(i));
5457
5458         mutex_unlock(&cgroup_mutex);
5459         return 0;
5460 }
5461
5462 static int cgroupstats_open(struct inode *inode, struct file *file)
5463 {
5464         return single_open(file, proc_cgroupstats_show, NULL);
5465 }
5466
5467 static const struct file_operations proc_cgroupstats_operations = {
5468         .open = cgroupstats_open,
5469         .read = seq_read,
5470         .llseek = seq_lseek,
5471         .release = single_release,
5472 };
5473
5474 /**
5475  * cgroup_fork - initialize cgroup related fields during copy_process()
5476  * @child: pointer to task_struct of forking parent process.
5477  *
5478  * A task is associated with the init_css_set until cgroup_post_fork()
5479  * attaches it to the parent's css_set.  Empty cg_list indicates that
5480  * @child isn't holding reference to its css_set.
5481  */
5482 void cgroup_fork(struct task_struct *child)
5483 {
5484         RCU_INIT_POINTER(child->cgroups, &init_css_set);
5485         INIT_LIST_HEAD(&child->cg_list);
5486 }
5487
5488 /**
5489  * cgroup_can_fork - called on a new task before the process is exposed
5490  * @child: the task in question.
5491  *
5492  * This calls the subsystem can_fork() callbacks. If the can_fork() callback
5493  * returns an error, the fork aborts with that error code. This allows for
5494  * a cgroup subsystem to conditionally allow or deny new forks.
5495  */
5496 int cgroup_can_fork(struct task_struct *child)
5497 {
5498         struct cgroup_subsys *ss;
5499         int i, j, ret;
5500
5501         for_each_subsys_which(ss, i, &have_canfork_callback) {
5502                 ret = ss->can_fork(child);
5503                 if (ret)
5504                         goto out_revert;
5505         }
5506
5507         return 0;
5508
5509 out_revert:
5510         for_each_subsys(ss, j) {
5511                 if (j >= i)
5512                         break;
5513                 if (ss->cancel_fork)
5514                         ss->cancel_fork(child);
5515         }
5516
5517         return ret;
5518 }
5519
5520 /**
5521  * cgroup_cancel_fork - called if a fork failed after cgroup_can_fork()
5522  * @child: the task in question
5523  *
5524  * This calls the cancel_fork() callbacks if a fork failed *after*
5525  * cgroup_can_fork() succeded.
5526  */
5527 void cgroup_cancel_fork(struct task_struct *child)
5528 {
5529         struct cgroup_subsys *ss;
5530         int i;
5531
5532         for_each_subsys(ss, i)
5533                 if (ss->cancel_fork)
5534                         ss->cancel_fork(child);
5535 }
5536
5537 /**
5538  * cgroup_post_fork - called on a new task after adding it to the task list
5539  * @child: the task in question
5540  *
5541  * Adds the task to the list running through its css_set if necessary and
5542  * call the subsystem fork() callbacks.  Has to be after the task is
5543  * visible on the task list in case we race with the first call to
5544  * cgroup_task_iter_start() - to guarantee that the new task ends up on its
5545  * list.
5546  */
5547 void cgroup_post_fork(struct task_struct *child)
5548 {
5549         struct cgroup_subsys *ss;
5550         int i;
5551
5552         /*
5553          * This may race against cgroup_enable_task_cg_lists().  As that
5554          * function sets use_task_css_set_links before grabbing
5555          * tasklist_lock and we just went through tasklist_lock to add
5556          * @child, it's guaranteed that either we see the set
5557          * use_task_css_set_links or cgroup_enable_task_cg_lists() sees
5558          * @child during its iteration.
5559          *
5560          * If we won the race, @child is associated with %current's
5561          * css_set.  Grabbing css_set_lock guarantees both that the
5562          * association is stable, and, on completion of the parent's
5563          * migration, @child is visible in the source of migration or
5564          * already in the destination cgroup.  This guarantee is necessary
5565          * when implementing operations which need to migrate all tasks of
5566          * a cgroup to another.
5567          *
5568          * Note that if we lose to cgroup_enable_task_cg_lists(), @child
5569          * will remain in init_css_set.  This is safe because all tasks are
5570          * in the init_css_set before cg_links is enabled and there's no
5571          * operation which transfers all tasks out of init_css_set.
5572          */
5573         if (use_task_css_set_links) {
5574                 struct css_set *cset;
5575
5576                 spin_lock_bh(&css_set_lock);
5577                 cset = task_css_set(current);
5578                 if (list_empty(&child->cg_list)) {
5579                         get_css_set(cset);
5580                         css_set_move_task(child, NULL, cset, false);
5581                 }
5582                 spin_unlock_bh(&css_set_lock);
5583         }
5584
5585         /*
5586          * Call ss->fork().  This must happen after @child is linked on
5587          * css_set; otherwise, @child might change state between ->fork()
5588          * and addition to css_set.
5589          */
5590         for_each_subsys_which(ss, i, &have_fork_callback)
5591                 ss->fork(child);
5592 }
5593
5594 /**
5595  * cgroup_exit - detach cgroup from exiting task
5596  * @tsk: pointer to task_struct of exiting process
5597  *
5598  * Description: Detach cgroup from @tsk and release it.
5599  *
5600  * Note that cgroups marked notify_on_release force every task in
5601  * them to take the global cgroup_mutex mutex when exiting.
5602  * This could impact scaling on very large systems.  Be reluctant to
5603  * use notify_on_release cgroups where very high task exit scaling
5604  * is required on large systems.
5605  *
5606  * We set the exiting tasks cgroup to the root cgroup (top_cgroup).  We
5607  * call cgroup_exit() while the task is still competent to handle
5608  * notify_on_release(), then leave the task attached to the root cgroup in
5609  * each hierarchy for the remainder of its exit.  No need to bother with
5610  * init_css_set refcnting.  init_css_set never goes away and we can't race
5611  * with migration path - PF_EXITING is visible to migration path.
5612  */
5613 void cgroup_exit(struct task_struct *tsk)
5614 {
5615         struct cgroup_subsys *ss;
5616         struct css_set *cset;
5617         int i;
5618
5619         /*
5620          * Unlink from @tsk from its css_set.  As migration path can't race
5621          * with us, we can check css_set and cg_list without synchronization.
5622          */
5623         cset = task_css_set(tsk);
5624
5625         if (!list_empty(&tsk->cg_list)) {
5626                 spin_lock_bh(&css_set_lock);
5627                 css_set_move_task(tsk, cset, NULL, false);
5628                 spin_unlock_bh(&css_set_lock);
5629         } else {
5630                 get_css_set(cset);
5631         }
5632
5633         /* see cgroup_post_fork() for details */
5634         for_each_subsys_which(ss, i, &have_exit_callback)
5635                 ss->exit(tsk);
5636 }
5637
5638 void cgroup_free(struct task_struct *task)
5639 {
5640         struct css_set *cset = task_css_set(task);
5641         struct cgroup_subsys *ss;
5642         int ssid;
5643
5644         for_each_subsys_which(ss, ssid, &have_free_callback)
5645                 ss->free(task);
5646
5647         put_css_set(cset);
5648 }
5649
5650 static void check_for_release(struct cgroup *cgrp)
5651 {
5652         if (notify_on_release(cgrp) && !cgroup_is_populated(cgrp) &&
5653             !css_has_online_children(&cgrp->self) && !cgroup_is_dead(cgrp))
5654                 schedule_work(&cgrp->release_agent_work);
5655 }
5656
5657 /*
5658  * Notify userspace when a cgroup is released, by running the
5659  * configured release agent with the name of the cgroup (path
5660  * relative to the root of cgroup file system) as the argument.
5661  *
5662  * Most likely, this user command will try to rmdir this cgroup.
5663  *
5664  * This races with the possibility that some other task will be
5665  * attached to this cgroup before it is removed, or that some other
5666  * user task will 'mkdir' a child cgroup of this cgroup.  That's ok.
5667  * The presumed 'rmdir' will fail quietly if this cgroup is no longer
5668  * unused, and this cgroup will be reprieved from its death sentence,
5669  * to continue to serve a useful existence.  Next time it's released,
5670  * we will get notified again, if it still has 'notify_on_release' set.
5671  *
5672  * The final arg to call_usermodehelper() is UMH_WAIT_EXEC, which
5673  * means only wait until the task is successfully execve()'d.  The
5674  * separate release agent task is forked by call_usermodehelper(),
5675  * then control in this thread returns here, without waiting for the
5676  * release agent task.  We don't bother to wait because the caller of
5677  * this routine has no use for the exit status of the release agent
5678  * task, so no sense holding our caller up for that.
5679  */
5680 static void cgroup_release_agent(struct work_struct *work)
5681 {
5682         struct cgroup *cgrp =
5683                 container_of(work, struct cgroup, release_agent_work);
5684         char *pathbuf = NULL, *agentbuf = NULL, *path;
5685         char *argv[3], *envp[3];
5686
5687         mutex_lock(&cgroup_mutex);
5688
5689         pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
5690         agentbuf = kstrdup(cgrp->root->release_agent_path, GFP_KERNEL);
5691         if (!pathbuf || !agentbuf)
5692                 goto out;
5693
5694         path = cgroup_path(cgrp, pathbuf, PATH_MAX);
5695         if (!path)
5696                 goto out;
5697
5698         argv[0] = agentbuf;
5699         argv[1] = path;
5700         argv[2] = NULL;
5701
5702         /* minimal command environment */
5703         envp[0] = "HOME=/";
5704         envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
5705         envp[2] = NULL;
5706
5707         mutex_unlock(&cgroup_mutex);
5708         call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
5709         goto out_free;
5710 out:
5711         mutex_unlock(&cgroup_mutex);
5712 out_free:
5713         kfree(agentbuf);
5714         kfree(pathbuf);
5715 }
5716
5717 static int __init cgroup_disable(char *str)
5718 {
5719         struct cgroup_subsys *ss;
5720         char *token;
5721         int i;
5722
5723         while ((token = strsep(&str, ",")) != NULL) {
5724                 if (!*token)
5725                         continue;
5726
5727                 for_each_subsys(ss, i) {
5728                         if (strcmp(token, ss->name) &&
5729                             strcmp(token, ss->legacy_name))
5730                                 continue;
5731                         cgroup_disable_mask |= 1 << i;
5732                 }
5733         }
5734         return 1;
5735 }
5736 __setup("cgroup_disable=", cgroup_disable);
5737
5738 /**
5739  * css_tryget_online_from_dir - get corresponding css from a cgroup dentry
5740  * @dentry: directory dentry of interest
5741  * @ss: subsystem of interest
5742  *
5743  * If @dentry is a directory for a cgroup which has @ss enabled on it, try
5744  * to get the corresponding css and return it.  If such css doesn't exist
5745  * or can't be pinned, an ERR_PTR value is returned.
5746  */
5747 struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
5748                                                        struct cgroup_subsys *ss)
5749 {
5750         struct kernfs_node *kn = kernfs_node_from_dentry(dentry);
5751         struct cgroup_subsys_state *css = NULL;
5752         struct cgroup *cgrp;
5753
5754         /* is @dentry a cgroup dir? */
5755         if (dentry->d_sb->s_type != &cgroup_fs_type || !kn ||
5756             kernfs_type(kn) != KERNFS_DIR)
5757                 return ERR_PTR(-EBADF);
5758
5759         rcu_read_lock();
5760
5761         /*
5762          * This path doesn't originate from kernfs and @kn could already
5763          * have been or be removed at any point.  @kn->priv is RCU
5764          * protected for this access.  See css_release_work_fn() for details.
5765          */
5766         cgrp = rcu_dereference(kn->priv);
5767         if (cgrp)
5768                 css = cgroup_css(cgrp, ss);
5769
5770         if (!css || !css_tryget_online(css))
5771                 css = ERR_PTR(-ENOENT);
5772
5773         rcu_read_unlock();
5774         return css;
5775 }
5776
5777 /**
5778  * css_from_id - lookup css by id
5779  * @id: the cgroup id
5780  * @ss: cgroup subsys to be looked into
5781  *
5782  * Returns the css if there's valid one with @id, otherwise returns NULL.
5783  * Should be called under rcu_read_lock().
5784  */
5785 struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss)
5786 {
5787         WARN_ON_ONCE(!rcu_read_lock_held());
5788         return id > 0 ? idr_find(&ss->css_idr, id) : NULL;
5789 }
5790
5791 /**
5792  * cgroup_get_from_path - lookup and get a cgroup from its default hierarchy path
5793  * @path: path on the default hierarchy
5794  *
5795  * Find the cgroup at @path on the default hierarchy, increment its
5796  * reference count and return it.  Returns pointer to the found cgroup on
5797  * success, ERR_PTR(-ENOENT) if @path doens't exist and ERR_PTR(-ENOTDIR)
5798  * if @path points to a non-directory.
5799  */
5800 struct cgroup *cgroup_get_from_path(const char *path)
5801 {
5802         struct kernfs_node *kn;
5803         struct cgroup *cgrp;
5804
5805         mutex_lock(&cgroup_mutex);
5806
5807         kn = kernfs_walk_and_get(cgrp_dfl_root.cgrp.kn, path);
5808         if (kn) {
5809                 if (kernfs_type(kn) == KERNFS_DIR) {
5810                         cgrp = kn->priv;
5811                         cgroup_get(cgrp);
5812                 } else {
5813                         cgrp = ERR_PTR(-ENOTDIR);
5814                 }
5815                 kernfs_put(kn);
5816         } else {
5817                 cgrp = ERR_PTR(-ENOENT);
5818         }
5819
5820         mutex_unlock(&cgroup_mutex);
5821         return cgrp;
5822 }
5823 EXPORT_SYMBOL_GPL(cgroup_get_from_path);
5824
5825 /*
5826  * sock->sk_cgrp_data handling.  For more info, see sock_cgroup_data
5827  * definition in cgroup-defs.h.
5828  */
5829 #ifdef CONFIG_SOCK_CGROUP_DATA
5830
5831 #if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID)
5832
5833 DEFINE_SPINLOCK(cgroup_sk_update_lock);
5834 static bool cgroup_sk_alloc_disabled __read_mostly;
5835
5836 void cgroup_sk_alloc_disable(void)
5837 {
5838         if (cgroup_sk_alloc_disabled)
5839                 return;
5840         pr_info("cgroup: disabling cgroup2 socket matching due to net_prio or net_cls activation\n");
5841         cgroup_sk_alloc_disabled = true;
5842 }
5843
5844 #else
5845
5846 #define cgroup_sk_alloc_disabled        false
5847
5848 #endif
5849
5850 void cgroup_sk_alloc(struct sock_cgroup_data *skcd)
5851 {
5852         if (cgroup_sk_alloc_disabled)
5853                 return;
5854
5855         rcu_read_lock();
5856
5857         while (true) {
5858                 struct css_set *cset;
5859
5860                 cset = task_css_set(current);
5861                 if (likely(cgroup_tryget(cset->dfl_cgrp))) {
5862                         skcd->val = (unsigned long)cset->dfl_cgrp;
5863                         break;
5864                 }
5865                 cpu_relax();
5866         }
5867
5868         rcu_read_unlock();
5869 }
5870
5871 void cgroup_sk_free(struct sock_cgroup_data *skcd)
5872 {
5873         cgroup_put(sock_cgroup_ptr(skcd));
5874 }
5875
5876 #endif  /* CONFIG_SOCK_CGROUP_DATA */
5877
5878 #ifdef CONFIG_CGROUP_DEBUG
5879 static struct cgroup_subsys_state *
5880 debug_css_alloc(struct cgroup_subsys_state *parent_css)
5881 {
5882         struct cgroup_subsys_state *css = kzalloc(sizeof(*css), GFP_KERNEL);
5883
5884         if (!css)
5885                 return ERR_PTR(-ENOMEM);
5886
5887         return css;
5888 }
5889
5890 static void debug_css_free(struct cgroup_subsys_state *css)
5891 {
5892         kfree(css);
5893 }
5894
5895 static u64 debug_taskcount_read(struct cgroup_subsys_state *css,
5896                                 struct cftype *cft)
5897 {
5898         return cgroup_task_count(css->cgroup);
5899 }
5900
5901 static u64 current_css_set_read(struct cgroup_subsys_state *css,
5902                                 struct cftype *cft)
5903 {
5904         return (u64)(unsigned long)current->cgroups;
5905 }
5906
5907 static u64 current_css_set_refcount_read(struct cgroup_subsys_state *css,
5908                                          struct cftype *cft)
5909 {
5910         u64 count;
5911
5912         rcu_read_lock();
5913         count = atomic_read(&task_css_set(current)->refcount);
5914         rcu_read_unlock();
5915         return count;
5916 }
5917
5918 static int current_css_set_cg_links_read(struct seq_file *seq, void *v)
5919 {
5920         struct cgrp_cset_link *link;
5921         struct css_set *cset;
5922         char *name_buf;
5923
5924         name_buf = kmalloc(NAME_MAX + 1, GFP_KERNEL);
5925         if (!name_buf)
5926                 return -ENOMEM;
5927
5928         spin_lock_bh(&css_set_lock);
5929         rcu_read_lock();
5930         cset = rcu_dereference(current->cgroups);
5931         list_for_each_entry(link, &cset->cgrp_links, cgrp_link) {
5932                 struct cgroup *c = link->cgrp;
5933
5934                 cgroup_name(c, name_buf, NAME_MAX + 1);
5935                 seq_printf(seq, "Root %d group %s\n",
5936                            c->root->hierarchy_id, name_buf);
5937         }
5938         rcu_read_unlock();
5939         spin_unlock_bh(&css_set_lock);
5940         kfree(name_buf);
5941         return 0;
5942 }
5943
5944 #define MAX_TASKS_SHOWN_PER_CSS 25
5945 static int cgroup_css_links_read(struct seq_file *seq, void *v)
5946 {
5947         struct cgroup_subsys_state *css = seq_css(seq);
5948         struct cgrp_cset_link *link;
5949
5950         spin_lock_bh(&css_set_lock);
5951         list_for_each_entry(link, &css->cgroup->cset_links, cset_link) {
5952                 struct css_set *cset = link->cset;
5953                 struct task_struct *task;
5954                 int count = 0;
5955
5956                 seq_printf(seq, "css_set %p\n", cset);
5957
5958                 list_for_each_entry(task, &cset->tasks, cg_list) {
5959                         if (count++ > MAX_TASKS_SHOWN_PER_CSS)
5960                                 goto overflow;
5961                         seq_printf(seq, "  task %d\n", task_pid_vnr(task));
5962                 }
5963
5964                 list_for_each_entry(task, &cset->mg_tasks, cg_list) {
5965                         if (count++ > MAX_TASKS_SHOWN_PER_CSS)
5966                                 goto overflow;
5967                         seq_printf(seq, "  task %d\n", task_pid_vnr(task));
5968                 }
5969                 continue;
5970         overflow:
5971                 seq_puts(seq, "  ...\n");
5972         }
5973         spin_unlock_bh(&css_set_lock);
5974         return 0;
5975 }
5976
5977 static u64 releasable_read(struct cgroup_subsys_state *css, struct cftype *cft)
5978 {
5979         return (!cgroup_is_populated(css->cgroup) &&
5980                 !css_has_online_children(&css->cgroup->self));
5981 }
5982
5983 static struct cftype debug_files[] =  {
5984         {
5985                 .name = "taskcount",
5986                 .read_u64 = debug_taskcount_read,
5987         },
5988
5989         {
5990                 .name = "current_css_set",
5991                 .read_u64 = current_css_set_read,
5992         },
5993
5994         {
5995                 .name = "current_css_set_refcount",
5996                 .read_u64 = current_css_set_refcount_read,
5997         },
5998
5999         {
6000                 .name = "current_css_set_cg_links",
6001                 .seq_show = current_css_set_cg_links_read,
6002         },
6003
6004         {
6005                 .name = "cgroup_css_links",
6006                 .seq_show = cgroup_css_links_read,
6007         },
6008
6009         {
6010                 .name = "releasable",
6011                 .read_u64 = releasable_read,
6012         },
6013
6014         { }     /* terminate */
6015 };
6016
6017 struct cgroup_subsys debug_cgrp_subsys = {
6018         .css_alloc = debug_css_alloc,
6019         .css_free = debug_css_free,
6020         .legacy_cftypes = debug_files,
6021 };
6022 #endif /* CONFIG_CGROUP_DEBUG */