/* *  Generic process-grouping system. * *  Based originally on the cpuset system, extracted by Paul Menage *  Copyright (C) 2006 Google, Inc * *  Notifications support *  Copyright (C) 2009 Nokia Corporation *  Author: Kirill A. Shutemov * *  Copyright notices from the original cpuset code: *  -------------------------------------------------- *  Copyright (C) 2003 BULL SA. *  Copyright (C) 2004-2006 Silicon Graphics, Inc. * *  Portions derived from Patrick Mochel's sysfs code. *  sysfs is Copyright (c) 2001-3 Patrick Mochel * *  2003-10-10 Written by Simon Derr. *  2003-10-22 Updates by Stephen Hemminger. *  2004 May-July Rework by Paul Jackson. *  --------------------------------------------------- * *  This file is subject to the terms and conditions of the GNU General Public *  License.  See the file COPYING in the main directory of the Linux *  distribution for more details. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/cgroup.h>#include <linux/cred.h>#include <linux/ctype.h>#include <linux/errno.h>#include <linux/init_task.h>#include <linux/kernel.h>#include <linux/list.h>#include <linux/magic.h>#include <linux/mm.h>#include <linux/mutex.h>#include <linux/mount.h>#include <linux/pagemap.h>#include <linux/proc_fs.h>#include <linux/rcupdate.h>#include <linux/sched.h>#include <linux/slab.h>#include <linux/spinlock.h>#include <linux/rwsem.h>#include <linux/string.h>#include <linux/sort.h>#include <linux/kmod.h>#include <linux/delayacct.h>#include <linux/cgroupstats.h>#include <linux/hashtable.h>#include <linux/pid_namespace.h>#include <linux/idr.h>#include <linux/vmalloc.h> /* TODO: replace with more sophisticated array */#include <linux/kthread.h>#include <linux/delay.h> #include <linux/atomic.h> /* * pidlists linger the following amount before being destroyed.  The goal * is avoiding frequent destruction in the middle of consecutive read calls * Expiring in the middle is a performance problem not a correctness one. * 1 sec should be enough. */#define CGROUP_PIDLIST_DESTROY_DELAY	HZ #define CGROUP_FILE_NAME_MAX		(MAX_CGROUP_TYPE_NAMELEN +	\					 MAX_CFTYPE_NAME + 2) /* * cgroup_mutex is the master lock.  Any modification to cgroup or its * hierarchy must be performed while holding it. * * css_set_rwsem protects task->cgroups pointer, the list of css_set * objects, and the chain of tasks off each css_set. * * These locks are exported if CONFIG_PROVE_RCU so that accessors in * cgroup.h can use them for lockdep annotations. */#ifdef CONFIG_PROVE_RCUDEFINE_MUTEX(cgroup_mutex);DECLARE_RWSEM(css_set_rwsem);EXPORT_SYMBOL_GPL(cgroup_mutex);EXPORT_SYMBOL_GPL(css_set_rwsem);#elsestatic DEFINE_MUTEX(cgroup_mutex);static DECLARE_RWSEM(css_set_rwsem);#endif /* * Protects cgroup_idr and css_idr so that IDs can be released without * grabbing cgroup_mutex. */static DEFINE_SPINLOCK(cgroup_idr_lock); /* * Protects cgroup_subsys->release_agent_path.  Modifying it also requires * cgroup_mutex.  Reading requires either cgroup_mutex or this spinlock. */static DEFINE_SPINLOCK(release_agent_path_lock); #define cgroup_assert_mutex_or_rcu_locked()				\	rcu_lockdep_assert(rcu_read_lock_held() ||			\			   lockdep_is_held(&cgroup_mutex),		\			   "cgroup_mutex or RCU read lock required"); /* * cgroup destruction makes heavy use of work items and there can be a lot * of concurrent destructions.  Use a separate workqueue so that cgroup * destruction work items don't end up filling up max_active of system_wq * which may lead to deadlock. */static struct workqueue_struct *cgroup_destroy_wq; /* * pidlist destructions need to be flushed on cgroup destruction.  Use a * separate workqueue as flush domain. */static struct workqueue_struct *cgroup_pidlist_destroy_wq; /* generate an array of cgroup subsystem pointers */#define SUBSYS(_x) [_x ## _cgrp_id] = &_x ## _cgrp_subsys,static struct cgroup_subsys *cgroup_subsys[] = {#include <linux/cgroup_subsys.h>};#undef SUBSYS /* array of cgroup subsystem names */#define SUBSYS(_x) [_x ## _cgrp_id] = #_x,static const char *cgroup_subsys_name[] = {#include <linux/cgroup_subsys.h>};#undef SUBSYS /* * The default hierarchy, reserved for the subsystems that are otherwise * unattached - it never has more than a single cgroup, and all tasks are * part of that cgroup. */struct cgroup_root cgrp_dfl_root; /* * The default hierarchy always exists but is hidden until mounted for the * first time.  This is for backward compatibility. */static bool cgrp_dfl_root_visible; /* * Set by the boot param of the same name and makes subsystems with NULL * ->dfl_files to use ->legacy_files on the default hierarchy. */static bool cgroup_legacy_files_on_dfl; /* some controllers are not supported in the default hierarchy */static unsigned int cgrp_dfl_root_inhibit_ss_mask; /* The list of hierarchy roots */ static LIST_HEAD(cgroup_roots);static int cgroup_root_count; /* hierarchy ID allocation and mapping, protected by cgroup_mutex */static DEFINE_IDR(cgroup_hierarchy_idr); /* * Assign a monotonically increasing serial number to csses.  It guarantees * cgroups with bigger numbers are newer than those with smaller numbers. * Also, as csses are always appended to the parent's ->children list, it * guarantees that sibling csses are always sorted in the ascending serial * number order on the list.  Protected by cgroup_mutex. */static u64 css_serial_nr_next = 1; /* This flag indicates whether tasks in the fork and exit paths should * check for fork/exit handlers to call. This avoids us having to do * extra work in the fork/exit path if none of the subsystems need to * be called. */static int need_forkexit_callback __read_mostly; static struct cftype cgroup_dfl_base_files[];static struct cftype cgroup_legacy_base_files[]; static int rebind_subsystems(struct cgroup_root *dst_root,			     unsigned int ss_mask);static int cgroup_destroy_locked(struct cgroup *cgrp);static int create_css(struct cgroup *cgrp, struct cgroup_subsys *ss,		      bool visible);static void css_release(struct percpu_ref *ref);static void kill_css(struct cgroup_subsys_state *css);static int cgroup_addrm_files(struct cgroup *cgrp, struct cftype cfts[],			      bool is_add); /* IDR wrappers which synchronize using cgroup_idr_lock */static int cgroup_idr_alloc(struct idr *idr, void *ptr, int start, int end,			    gfp_t gfp_mask){	int ret; 	idr_preload(gfp_mask);	spin_lock_bh(&cgroup_idr_lock);	ret = idr_alloc(idr, ptr, start, end, gfp_mask);	spin_unlock_bh(&cgroup_idr_lock);	idr_preload_end();	return ret;} static void *cgroup_idr_replace(struct idr *idr, void *ptr, int id){	void *ret; 	spin_lock_bh(&cgroup_idr_lock);	ret = idr_replace(idr, ptr, id);	spin_unlock_bh(&cgroup_idr_lock);	return ret;} static void cgroup_idr_remove(struct idr *idr, int id){	spin_lock_bh(&cgroup_idr_lock);	idr_remove(idr, id);	spin_unlock_bh(&cgroup_idr_lock);} static struct cgroup *cgroup_parent(struct cgroup *cgrp){	struct cgroup_subsys_state *parent_css = cgrp->self.parent; 	if (parent_css)		return container_of(parent_css, struct cgroup, self);	return NULL;} /** * cgroup_css - obtain a cgroup's css for the specified subsystem * @cgrp: the cgroup of interest * @ss: the subsystem of interest (%NULL returns @cgrp->self) * * Return @cgrp's css (cgroup_subsys_state) associated with @ss.  This * function must be called either under cgroup_mutex or rcu_read_lock() and * the caller is responsible for pinning the returned css if it wants to * keep accessing it outside the said locks.  This function may return * %NULL if @cgrp doesn't have @subsys_id enabled. */static struct cgroup_subsys_state *cgroup_css(struct cgroup *cgrp,					      struct cgroup_subsys *ss){	if (ss)		return rcu_dereference_check(cgrp->subsys[ss->id],					lockdep_is_held(&cgroup_mutex));	else		return &cgrp->self;} /** * cgroup_e_css - obtain a cgroup's effective css for the specified subsystem * @cgrp: the cgroup of interest * @ss: the subsystem of interest (%NULL returns @cgrp->self) * * Similar to cgroup_css() but returns the effctive css, which is defined * as the matching css of the nearest ancestor including self which has @ss * enabled.  If @ss is associated with the hierarchy @cgrp is on, this * function is guaranteed to return non-NULL css. */static struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgrp,						struct cgroup_subsys *ss){	lockdep_assert_held(&cgroup_mutex); 	if (!ss)		return &cgrp->self; 	if (!(cgrp->root->subsys_mask & (1 << ss->id)))		return NULL; 	/*	 * This function is used while updating css associations and thus	 * can't test the csses directly.  Use ->child_subsys_mask.	 */	while (cgroup_parent(cgrp) &&	       !(cgroup_parent(cgrp)->child_subsys_mask & (1 << ss->id)))		cgrp = cgroup_parent(cgrp); 	return cgroup_css(cgrp, ss);} /** * cgroup_get_e_css - get a cgroup's effective css for the specified subsystem * @cgrp: the cgroup of interest * @ss: the subsystem of interest * * Find and get the effective css of @cgrp for @ss.  The effective css is * defined as the matching css of the nearest ancestor including self which * has @ss enabled.  If @ss is not mounted on the hierarchy @cgrp is on, * the root css is returned, so this function always returns a valid css. * The returned css must be put using css_put(). */struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgrp,					     struct cgroup_subsys *ss){	struct cgroup_subsys_state *css; 	rcu_read_lock(); 	do {		css = cgroup_css(cgrp, ss); 		if (css && css_tryget_online(css))			goto out_unlock;		cgrp = cgroup_parent(cgrp);	} while (cgrp); 	css = init_css_set.subsys[ss->id];	css_get(css);out_unlock:	rcu_read_unlock();	return css;} /* convenient tests for these bits */static inline bool cgroup_is_dead(const struct cgroup *cgrp){	return !(cgrp->self.flags & CSS_ONLINE);} struct cgroup_subsys_state *of_css(struct kernfs_open_file *of){	struct cgroup *cgrp = of->kn->parent->priv;	struct cftype *cft = of_cft(of); 	/*	 * This is open and unprotected implementation of cgroup_css().	 * seq_css() is only called from a kernfs file operation which has	 * an active reference on the file.  Because all the subsystem	 * files are drained before a css is disassociated with a cgroup,	 * the matching css from the cgroup's subsys table is guaranteed to	 * be and stay valid until the enclosing operation is complete.	 */	if (cft->ss)		return rcu_dereference_raw(cgrp->subsys[cft->ss->id]);	else		return &cgrp->self;}EXPORT_SYMBOL_GPL(of_css); /** * cgroup_is_descendant - test ancestry * @cgrp: the cgroup to be tested * @ancestor: possible ancestor of @cgrp * * Test whether @cgrp is a descendant of @ancestor.  It also returns %true * if @cgrp == @ancestor.  This function is safe to call as long as @cgrp * and @ancestor are accessible. */bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor){	while (cgrp) {		if (cgrp == ancestor)			return true;		cgrp = cgroup_parent(cgrp);	}	return false;} static int notify_on_release(const struct cgroup *cgrp){	return test_bit(CGRP_NOTIFY_ON_RELEASE, &cgrp->flags);} /** * for_each_css - iterate all css's of a cgroup * @css: the iteration cursor * @ssid: the index of the subsystem, CGROUP_SUBSYS_COUNT after reaching the end * @cgrp: the target cgroup to iterate css's of * * Should be called under cgroup_[tree_]mutex. */#define for_each_css(css, ssid, cgrp)					\	for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT; (ssid)++)	\		if (!((css) = rcu_dereference_check(			\				(cgrp)->subsys[(ssid)],			\				lockdep_is_held(&cgroup_mutex)))) { }	\		else /** * for_each_e_css - iterate all effective css's of a cgroup * @css: the iteration cursor * @ssid: the index of the subsystem, CGROUP_SUBSYS_COUNT after reaching the end * @cgrp: the target cgroup to iterate css's of * * Should be called under cgroup_[tree_]mutex. */#define for_each_e_css(css, ssid, cgrp)					\	for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT; (ssid)++)	\		if (!((css) = cgroup_e_css(cgrp, cgroup_subsys[(ssid)]))) \			;						\		else /** * for_each_subsys - iterate all enabled cgroup subsystems * @ss: the iteration cursor * @ssid: the index of @ss, CGROUP_SUBSYS_COUNT after reaching the end */#define for_each_subsys(ss, ssid)					\	for ((ssid) = 0; (ssid) < CGROUP_SUBSYS_COUNT &&		\	     (((ss) = cgroup_subsys[ssid]) || true); (ssid)++) /* iterate across the hierarchies */#define for_each_root(root)						\	list_for_each_entry((root), &cgroup_roots, root_list) /* iterate over child cgrps, lock should be held throughout iteration */#define cgroup_for_each_live_child(child, cgrp)				\	list_for_each_entry((child), &(cgrp)->self.children, self.sibling) \		if (({ lockdep_assert_held(&cgroup_mutex);		\		       cgroup_is_dead(child); }))			\			;						\		else static void cgroup_release_agent(struct work_struct *work);static void check_for_release(struct cgroup *cgrp); /* * A cgroup can be associated with multiple css_sets as different tasks may * belong to different cgroups on different hierarchies.  In the other * direction, a css_set is naturally associated with multiple cgroups. * This M:N relationship is represented by the following link structure * which exists for each association and allows traversing the associations * from both sides. */struct cgrp_cset_link {	/* the cgroup and css_set this link associates */	struct cgroup		*cgrp;	struct css_set		*cset; 	/* list of cgrp_cset_links anchored at cgrp->cset_links */	struct list_head	cset_link; 	/* list of cgrp_cset_links anchored at css_set->cgrp_links */	struct list_head	cgrp_link;}; /* * The default css_set - used by init and its children prior to any * hierarchies being mounted. It contains a pointer to the root state * for each subsystem. Also used to anchor the list of css_sets. Not * reference-counted, to improve performance when child cgroups * haven't been created. */struct css_set init_css_set = {	.refcount		= ATOMIC_INIT(1),	.cgrp_links		= LIST_HEAD_INIT(init_css_set.cgrp_links),	.tasks			= LIST_HEAD_INIT(init_css_set.tasks),	.mg_tasks		= LIST_HEAD_INIT(init_css_set.mg_tasks),	.mg_preload_node	= LIST_HEAD_INIT(init_css_set.mg_preload_node),	.mg_node		= LIST_HEAD_INIT(init_css_set.mg_node),}; static int css_set_count	= 1;	/* 1 for init_css_set */ /** * cgroup_update_populated - updated populated count of a cgroup * @cgrp: the target cgroup * @populated: inc or dec populated count * * @cgrp is either getting the first task (css_set) or losing the last. * Update @cgrp->populated_cnt accordingly.  The count is propagated * towards root so that a given cgroup's populated_cnt is zero iff the * cgroup and all its descendants are empty. * * @cgrp's interface file "cgroup.populated" is zero if * @cgrp->populated_cnt is zero and 1 otherwise.  When @cgrp->populated_cnt * changes from or to zero, userland is notified that the content of the * interface file has changed.  This can be used to detect when @cgrp and * its descendants become populated or empty. */static void cgroup_update_populated(struct cgroup *cgrp, bool populated){	lockdep_assert_held(&css_set_rwsem); 	do {		bool trigger; 		if (populated)			trigger = !cgrp->populated_cnt++;		else			trigger = !--cgrp->populated_cnt; 		if (!trigger)			break; 		if (cgrp->populated_kn)			kernfs_notify(cgrp->populated_kn);		cgrp = cgroup_parent(cgrp);	} while (cgrp);}

Lines 1–500 of 5597. Load more