/* SPDX-License-Identifier: GPL-2.0 *//* * linux/cgroup-defs.h - basic definitions for cgroup * * This file provides basic type and interface.  Include this file directly * only if necessary to avoid cyclic dependencies. */#ifndef _LINUX_CGROUP_DEFS_H#define _LINUX_CGROUP_DEFS_H #include <linux/limits.h>#include <linux/list.h>#include <linux/idr.h>#include <linux/wait.h>#include <linux/mutex.h>#include <linux/rcupdate.h>#include <linux/refcount.h>#include <linux/percpu-refcount.h>#include <linux/percpu-rwsem.h>#include <linux/u64_stats_sync.h>#include <linux/workqueue.h>#include <linux/bpf-cgroup.h>#include <linux/psi_types.h> #ifdef CONFIG_CGROUPS struct cgroup;struct cgroup_root;struct cgroup_subsys;struct cgroup_taskset;struct kernfs_node;struct kernfs_ops;struct kernfs_open_file;struct seq_file;struct poll_table_struct; #define MAX_CGROUP_TYPE_NAMELEN 32#define MAX_CGROUP_ROOT_NAMELEN 64#define MAX_CFTYPE_NAME		64 /* define the enumeration of all cgroup subsystems */#define SUBSYS(_x) _x ## _cgrp_id,enum cgroup_subsys_id {#include <linux/cgroup_subsys.h>	CGROUP_SUBSYS_COUNT,};#undef SUBSYS /* bits in struct cgroup_subsys_state flags field */enum {	CSS_NO_REF	= (1 << 0), /* no reference counting for this css */	CSS_ONLINE	= (1 << 1), /* between ->css_online() and ->css_offline() */	CSS_RELEASED	= (1 << 2), /* refcnt reached zero, released */	CSS_VISIBLE	= (1 << 3), /* css is visible to userland */	CSS_DYING	= (1 << 4), /* css is dying */}; /* bits in struct cgroup flags field */enum {	/* Control Group requires release notifications to userspace */	CGRP_NOTIFY_ON_RELEASE,	/*	 * Clone the parent's configuration when creating a new child	 * cpuset cgroup.  For historical reasons, this option can be	 * specified at mount time and thus is implemented here.	 */	CGRP_CPUSET_CLONE_CHILDREN, 	/* Control group has to be frozen. */	CGRP_FREEZE, 	/* Cgroup is frozen. */	CGRP_FROZEN,}; /* cgroup_root->flags */enum {	CGRP_ROOT_NOPREFIX	= (1 << 1), /* mounted subsystems have no named prefix */	CGRP_ROOT_XATTR		= (1 << 2), /* supports extended attributes */ 	/*	 * Consider namespaces as delegation boundaries.  If this flag is	 * set, controller specific interface files in a namespace root	 * aren't writeable from inside the namespace.	 */	CGRP_ROOT_NS_DELEGATE	= (1 << 3), 	/*	 * Enable cpuset controller in v1 cgroup to use v2 behavior.	 */	CGRP_ROOT_CPUSET_V2_MODE = (1 << 4), 	/*	 * Enable legacy local memory.events.	 */	CGRP_ROOT_MEMORY_LOCAL_EVENTS = (1 << 5),}; /* cftype->flags */enum {	CFTYPE_ONLY_ON_ROOT	= (1 << 0),	/* only create on root cgrp */	CFTYPE_NOT_ON_ROOT	= (1 << 1),	/* don't create on root cgrp */	CFTYPE_NS_DELEGATABLE	= (1 << 2),	/* writeable beyond delegation boundaries */ 	CFTYPE_NO_PREFIX	= (1 << 3),	/* (DON'T USE FOR NEW FILES) no subsys prefix */	CFTYPE_WORLD_WRITABLE	= (1 << 4),	/* (DON'T USE FOR NEW FILES) S_IWUGO */	CFTYPE_DEBUG		= (1 << 5),	/* create when cgroup_debug */ 	/* internal flags, do not use outside cgroup core proper */	__CFTYPE_ONLY_ON_DFL	= (1 << 16),	/* only on default hierarchy */	__CFTYPE_NOT_ON_DFL	= (1 << 17),	/* not on default hierarchy */}; /* * cgroup_file is the handle for a file instance created in a cgroup which * is used, for example, to generate file changed notifications.  This can * be obtained by setting cftype->file_offset. */struct cgroup_file {	/* do not access any fields from outside cgroup core */	struct kernfs_node *kn;	unsigned long notified_at;	struct timer_list notify_timer;}; /* * Per-subsystem/per-cgroup state maintained by the system.  This is the * fundamental structural building block that controllers deal with. * * Fields marked with "PI:" are public and immutable and may be accessed * directly without synchronization. */struct cgroup_subsys_state {	/* PI: the cgroup that this css is attached to */	struct cgroup *cgroup; 	/* PI: the cgroup subsystem that this css is attached to */	struct cgroup_subsys *ss; 	/* reference count - access via css_[try]get() and css_put() */	struct percpu_ref refcnt; 	/* siblings list anchored at the parent's ->children */	struct list_head sibling;	struct list_head children; 	/* flush target list anchored at cgrp->rstat_css_list */	struct list_head rstat_css_node; 	/*	 * PI: Subsys-unique ID.  0 is unused and root is always 1.  The	 * matching css can be looked up using css_from_id().	 */	int id; 	unsigned int flags; 	/*	 * Monotonically increasing unique serial number which defines a	 * uniform order among all csses.  It's guaranteed that all	 * ->children lists are in the ascending order of ->serial_nr and	 * used to allow interrupting and resuming iterations.	 */	u64 serial_nr; 	/*	 * Incremented by online self and children.  Used to guarantee that	 * parents are not offlined before their children.	 */	atomic_t online_cnt; 	/* percpu_ref killing and RCU release */	struct work_struct destroy_work;	struct rcu_work destroy_rwork; 	/*	 * PI: the parent css.	Placed here for cache proximity to following	 * fields of the containing structure.	 */	struct cgroup_subsys_state *parent;}; /* * A css_set is a structure holding pointers to a set of * cgroup_subsys_state objects. This saves space in the task struct * object and speeds up fork()/exit(), since a single inc/dec and a * list_add()/del() can bump the reference count on the entire cgroup * set for a task. */struct css_set {	/*	 * Set of subsystem states, one for each subsystem. This array is	 * immutable after creation apart from the init_css_set during	 * subsystem registration (at boot time).	 */	struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT]; 	/* reference count */	refcount_t refcount; 	/*	 * For a domain cgroup, the following points to self.  If threaded,	 * to the matching cset of the nearest domain ancestor.  The	 * dom_cset provides access to the domain cgroup and its csses to	 * which domain level resource consumptions should be charged.	 */	struct css_set *dom_cset; 	/* the default cgroup associated with this css_set */	struct cgroup *dfl_cgrp; 	/* internal task count, protected by css_set_lock */	int nr_tasks; 	/*	 * Lists running through all tasks using this cgroup group.	 * mg_tasks lists tasks which belong to this cset but are in the	 * process of being migrated out or in.  Protected by	 * css_set_rwsem, but, during migration, once tasks are moved to	 * mg_tasks, it can be read safely while holding cgroup_mutex.	 */	struct list_head tasks;	struct list_head mg_tasks;	struct list_head dying_tasks; 	/* all css_task_iters currently walking this cset */	struct list_head task_iters; 	/*	 * On the default hierarhcy, ->subsys[ssid] may point to a css	 * attached to an ancestor instead of the cgroup this css_set is	 * associated with.  The following node is anchored at	 * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to	 * iterate through all css's attached to a given cgroup.	 */	struct list_head e_cset_node[CGROUP_SUBSYS_COUNT]; 	/* all threaded csets whose ->dom_cset points to this cset */	struct list_head threaded_csets;	struct list_head threaded_csets_node; 	/*	 * List running through all cgroup groups in the same hash	 * slot. Protected by css_set_lock	 */	struct hlist_node hlist; 	/*	 * List of cgrp_cset_links pointing at cgroups referenced from this	 * css_set.  Protected by css_set_lock.	 */	struct list_head cgrp_links; 	/*	 * List of csets participating in the on-going migration either as	 * source or destination.  Protected by cgroup_mutex.	 */	struct list_head mg_preload_node;	struct list_head mg_node; 	/*	 * If this cset is acting as the source of migration the following	 * two fields are set.  mg_src_cgrp and mg_dst_cgrp are	 * respectively the source and destination cgroups of the on-going	 * migration.  mg_dst_cset is the destination cset the target tasks	 * on this cset should be migrated to.  Protected by cgroup_mutex.	 */	struct cgroup *mg_src_cgrp;	struct cgroup *mg_dst_cgrp;	struct css_set *mg_dst_cset; 	/* dead and being drained, ignore for migration */	bool dead; 	/* For RCU-protected deletion */	struct rcu_head rcu_head;}; struct cgroup_base_stat {	struct task_cputime cputime;}; /* * rstat - cgroup scalable recursive statistics.  Accounting is done * per-cpu in cgroup_rstat_cpu which is then lazily propagated up the * hierarchy on reads. * * When a stat gets updated, the cgroup_rstat_cpu and its ancestors are * linked into the updated tree.  On the following read, propagation only * considers and consumes the updated tree.  This makes reading O(the * number of descendants which have been active since last read) instead of * O(the total number of descendants). * * This is important because there can be a lot of (draining) cgroups which * aren't active and stat may be read frequently.  The combination can * become very expensive.  By propagating selectively, increasing reading * frequency decreases the cost of each read. * * This struct hosts both the fields which implement the above - * updated_children and updated_next - and the fields which track basic * resource statistics on top of it - bsync, bstat and last_bstat. */struct cgroup_rstat_cpu {	/*	 * ->bsync protects ->bstat.  These are the only fields which get	 * updated in the hot path.	 */	struct u64_stats_sync bsync;	struct cgroup_base_stat bstat; 	/*	 * Snapshots at the last reading.  These are used to calculate the	 * deltas to propagate to the global counters.	 */	struct cgroup_base_stat last_bstat; 	/*	 * Child cgroups with stat updates on this cpu since the last read	 * are linked on the parent's ->updated_children through	 * ->updated_next.	 *	 * In addition to being more compact, singly-linked list pointing	 * to the cgroup makes it unnecessary for each per-cpu struct to	 * point back to the associated cgroup.	 *	 * Protected by per-cpu cgroup_rstat_cpu_lock.	 */	struct cgroup *updated_children;	/* terminated by self cgroup */	struct cgroup *updated_next;		/* NULL iff not on the list */}; struct cgroup_freezer_state {	/* Should the cgroup and its descendants be frozen. */	bool freeze; 	/* Should the cgroup actually be frozen? */	int e_freeze; 	/* Fields below are protected by css_set_lock */ 	/* Number of frozen descendant cgroups */	int nr_frozen_descendants; 	/*	 * Number of tasks, which are counted as frozen:	 * frozen, SIGSTOPped, and PTRACEd.	 */	int nr_frozen_tasks;}; struct cgroup {	/* self css with NULL ->ss, points back to this cgroup */	struct cgroup_subsys_state self; 	unsigned long flags;		/* "unsigned long" so bitops work */ 	/*	 * idr allocated in-hierarchy ID.	 *	 * ID 0 is not used, the ID of the root cgroup is always 1, and a	 * new cgroup will be assigned with a smallest available ID.	 *	 * Allocating/Removing ID must be protected by cgroup_mutex.	 */	int id; 	/*	 * The depth this cgroup is at.  The root is at depth zero and each	 * step down the hierarchy increments the level.  This along with	 * ancestor_ids[] can determine whether a given cgroup is a	 * descendant of another without traversing the hierarchy.	 */	int level; 	/* Maximum allowed descent tree depth */	int max_depth; 	/*	 * Keep track of total numbers of visible and dying descent cgroups.	 * Dying cgroups are cgroups which were deleted by a user,	 * but are still existing because someone else is holding a reference.	 * max_descendants is a maximum allowed number of descent cgroups.	 *	 * nr_descendants and nr_dying_descendants are protected	 * by cgroup_mutex and css_set_lock. It's fine to read them holding	 * any of cgroup_mutex and css_set_lock; for writing both locks	 * should be held.	 */	int nr_descendants;	int nr_dying_descendants;	int max_descendants; 	/*	 * Each non-empty css_set associated with this cgroup contributes	 * one to nr_populated_csets.  The counter is zero iff this cgroup	 * doesn't have any tasks.	 *	 * All children which have non-zero nr_populated_csets and/or	 * nr_populated_children of their own contribute one to either	 * nr_populated_domain_children or nr_populated_threaded_children	 * depending on their type.  Each counter is zero iff all cgroups	 * of the type in the subtree proper don't have any tasks.	 */	int nr_populated_csets;	int nr_populated_domain_children;	int nr_populated_threaded_children; 	int nr_threaded_children;	/* # of live threaded child cgroups */ 	struct kernfs_node *kn;		/* cgroup kernfs entry */	struct cgroup_file procs_file;	/* handle for "cgroup.procs" */	struct cgroup_file events_file;	/* handle for "cgroup.events" */ 	/*	 * The bitmask of subsystems enabled on the child cgroups.	 * ->subtree_control is the one configured through	 * "cgroup.subtree_control" while ->child_ss_mask is the effective	 * one which may have more subsystems enabled.  Controller knobs	 * are made available iff it's enabled in ->subtree_control.	 */	u16 subtree_control;	u16 subtree_ss_mask;	u16 old_subtree_control;	u16 old_subtree_ss_mask; 	/* Private pointers for each registered subsystem */	struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT]; 	struct cgroup_root *root; 	/*	 * List of cgrp_cset_links pointing at css_sets with tasks in this	 * cgroup.  Protected by css_set_lock.	 */	struct list_head cset_links; 	/*	 * On the default hierarchy, a css_set for a cgroup with some	 * susbsys disabled will point to css's which are associated with	 * the closest ancestor which has the subsys enabled.  The	 * following lists all css_sets which point to this cgroup's css	 * for the given subsystem.	 */	struct list_head e_csets[CGROUP_SUBSYS_COUNT]; 	/*	 * If !threaded, self.  If threaded, it points to the nearest	 * domain ancestor.  Inside a threaded subtree, cgroups are exempt	 * from process granularity and no-internal-task constraint.	 * Domain level resource consumptions which aren't tied to a	 * specific task are charged to the dom_cgrp.	 */	struct cgroup *dom_cgrp;	struct cgroup *old_dom_cgrp;		/* used while enabling threaded */ 	/* per-cpu recursive resource statistics */	struct cgroup_rstat_cpu __percpu *rstat_cpu;	struct list_head rstat_css_list; 	/* cgroup basic resource statistics */	struct cgroup_base_stat pending_bstat;	/* pending from children */	struct cgroup_base_stat bstat;	struct prev_cputime prev_cputime;	/* for printing out cputime */ 	/*	 * list of pidlists, up to two for each namespace (one for procs, one	 * for tasks); created on demand.	 */	struct list_head pidlists;	struct mutex pidlist_mutex; 	/* used to wait for offlining of csses */	wait_queue_head_t offline_waitq; 	/* used to schedule release agent */	struct work_struct release_agent_work; 	/* used to track pressure stalls */	struct psi_group psi; 	/* used to store eBPF programs */	struct cgroup_bpf bpf; 	/* If there is block congestion on this cgroup. */	atomic_t congestion_count; 	/* Used to store internal freezer state */	struct cgroup_freezer_state freezer; 	/* ids of the ancestors at each level including self */	int ancestor_ids[];}; /* * A cgroup_root represents the root of a cgroup hierarchy, and may be * associated with a kernfs_root to form an active hierarchy.  This is * internal to cgroup core.  Don't access directly from controllers. */struct cgroup_root {	struct kernfs_root *kf_root;

Lines 1–500 of 879. Load more