Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  * linux/cgroup-defs.h - basic definitions for cgroup
       4                 :            :  *
       5                 :            :  * This file provides basic type and interface.  Include this file directly
       6                 :            :  * only if necessary to avoid cyclic dependencies.
       7                 :            :  */
       8                 :            : #ifndef _LINUX_CGROUP_DEFS_H
       9                 :            : #define _LINUX_CGROUP_DEFS_H
      10                 :            : 
      11                 :            : #include <linux/limits.h>
      12                 :            : #include <linux/list.h>
      13                 :            : #include <linux/idr.h>
      14                 :            : #include <linux/wait.h>
      15                 :            : #include <linux/mutex.h>
      16                 :            : #include <linux/rcupdate.h>
      17                 :            : #include <linux/refcount.h>
      18                 :            : #include <linux/percpu-refcount.h>
      19                 :            : #include <linux/percpu-rwsem.h>
      20                 :            : #include <linux/u64_stats_sync.h>
      21                 :            : #include <linux/workqueue.h>
      22                 :            : #include <linux/bpf-cgroup.h>
      23                 :            : #include <linux/psi_types.h>
      24                 :            : 
      25                 :            : #ifdef CONFIG_CGROUPS
      26                 :            : 
      27                 :            : struct cgroup;
      28                 :            : struct cgroup_root;
      29                 :            : struct cgroup_subsys;
      30                 :            : struct cgroup_taskset;
      31                 :            : struct kernfs_node;
      32                 :            : struct kernfs_ops;
      33                 :            : struct kernfs_open_file;
      34                 :            : struct seq_file;
      35                 :            : struct poll_table_struct;
      36                 :            : 
      37                 :            : #define MAX_CGROUP_TYPE_NAMELEN 32
      38                 :            : #define MAX_CGROUP_ROOT_NAMELEN 64
      39                 :            : #define MAX_CFTYPE_NAME         64
      40                 :            : 
      41                 :            : /* define the enumeration of all cgroup subsystems */
      42                 :            : #define SUBSYS(_x) _x ## _cgrp_id,
      43                 :            : enum cgroup_subsys_id {
      44                 :            : #include <linux/cgroup_subsys.h>
      45                 :            :         CGROUP_SUBSYS_COUNT,
      46                 :            : };
      47                 :            : #undef SUBSYS
      48                 :            : 
      49                 :            : /* bits in struct cgroup_subsys_state flags field */
      50                 :            : enum {
      51                 :            :         CSS_NO_REF      = (1 << 0), /* no reference counting for this css */
      52                 :            :         CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
      53                 :            :         CSS_RELEASED    = (1 << 2), /* refcnt reached zero, released */
      54                 :            :         CSS_VISIBLE     = (1 << 3), /* css is visible to userland */
      55                 :            :         CSS_DYING       = (1 << 4), /* css is dying */
      56                 :            : };
      57                 :            : 
      58                 :            : /* bits in struct cgroup flags field */
      59                 :            : enum {
      60                 :            :         /* Control Group requires release notifications to userspace */
      61                 :            :         CGRP_NOTIFY_ON_RELEASE,
      62                 :            :         /*
      63                 :            :          * Clone the parent's configuration when creating a new child
      64                 :            :          * cpuset cgroup.  For historical reasons, this option can be
      65                 :            :          * specified at mount time and thus is implemented here.
      66                 :            :          */
      67                 :            :         CGRP_CPUSET_CLONE_CHILDREN,
      68                 :            : 
      69                 :            :         /* Control group has to be frozen. */
      70                 :            :         CGRP_FREEZE,
      71                 :            : 
      72                 :            :         /* Cgroup is frozen. */
      73                 :            :         CGRP_FROZEN,
      74                 :            : };
      75                 :            : 
      76                 :            : /* cgroup_root->flags */
      77                 :            : enum {
      78                 :            :         CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
      79                 :            :         CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
      80                 :            : 
      81                 :            :         /*
      82                 :            :          * Consider namespaces as delegation boundaries.  If this flag is
      83                 :            :          * set, controller specific interface files in a namespace root
      84                 :            :          * aren't writeable from inside the namespace.
      85                 :            :          */
      86                 :            :         CGRP_ROOT_NS_DELEGATE   = (1 << 3),
      87                 :            : 
      88                 :            :         /*
      89                 :            :          * Enable cpuset controller in v1 cgroup to use v2 behavior.
      90                 :            :          */
      91                 :            :         CGRP_ROOT_CPUSET_V2_MODE = (1 << 4),
      92                 :            : 
      93                 :            :         /*
      94                 :            :          * Enable legacy local memory.events.
      95                 :            :          */
      96                 :            :         CGRP_ROOT_MEMORY_LOCAL_EVENTS = (1 << 5),
      97                 :            : };
      98                 :            : 
      99                 :            : /* cftype->flags */
     100                 :            : enum {
     101                 :            :         CFTYPE_ONLY_ON_ROOT     = (1 << 0),       /* only create on root cgrp */
     102                 :            :         CFTYPE_NOT_ON_ROOT      = (1 << 1),       /* don't create on root cgrp */
     103                 :            :         CFTYPE_NS_DELEGATABLE   = (1 << 2),       /* writeable beyond delegation boundaries */
     104                 :            : 
     105                 :            :         CFTYPE_NO_PREFIX        = (1 << 3),       /* (DON'T USE FOR NEW FILES) no subsys prefix */
     106                 :            :         CFTYPE_WORLD_WRITABLE   = (1 << 4),       /* (DON'T USE FOR NEW FILES) S_IWUGO */
     107                 :            :         CFTYPE_DEBUG            = (1 << 5),       /* create when cgroup_debug */
     108                 :            : 
     109                 :            :         /* internal flags, do not use outside cgroup core proper */
     110                 :            :         __CFTYPE_ONLY_ON_DFL    = (1 << 16),      /* only on default hierarchy */
     111                 :            :         __CFTYPE_NOT_ON_DFL     = (1 << 17),      /* not on default hierarchy */
     112                 :            : };
     113                 :            : 
     114                 :            : /*
     115                 :            :  * cgroup_file is the handle for a file instance created in a cgroup which
     116                 :            :  * is used, for example, to generate file changed notifications.  This can
     117                 :            :  * be obtained by setting cftype->file_offset.
     118                 :            :  */
     119                 :            : struct cgroup_file {
     120                 :            :         /* do not access any fields from outside cgroup core */
     121                 :            :         struct kernfs_node *kn;
     122                 :            :         unsigned long notified_at;
     123                 :            :         struct timer_list notify_timer;
     124                 :            : };
     125                 :            : 
     126                 :            : /*
     127                 :            :  * Per-subsystem/per-cgroup state maintained by the system.  This is the
     128                 :            :  * fundamental structural building block that controllers deal with.
     129                 :            :  *
     130                 :            :  * Fields marked with "PI:" are public and immutable and may be accessed
     131                 :            :  * directly without synchronization.
     132                 :            :  */
     133                 :            : struct cgroup_subsys_state {
     134                 :            :         /* PI: the cgroup that this css is attached to */
     135                 :            :         struct cgroup *cgroup;
     136                 :            : 
     137                 :            :         /* PI: the cgroup subsystem that this css is attached to */
     138                 :            :         struct cgroup_subsys *ss;
     139                 :            : 
     140                 :            :         /* reference count - access via css_[try]get() and css_put() */
     141                 :            :         struct percpu_ref refcnt;
     142                 :            : 
     143                 :            :         /* siblings list anchored at the parent's ->children */
     144                 :            :         struct list_head sibling;
     145                 :            :         struct list_head children;
     146                 :            : 
     147                 :            :         /* flush target list anchored at cgrp->rstat_css_list */
     148                 :            :         struct list_head rstat_css_node;
     149                 :            : 
     150                 :            :         /*
     151                 :            :          * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
     152                 :            :          * matching css can be looked up using css_from_id().
     153                 :            :          */
     154                 :            :         int id;
     155                 :            : 
     156                 :            :         unsigned int flags;
     157                 :            : 
     158                 :            :         /*
     159                 :            :          * Monotonically increasing unique serial number which defines a
     160                 :            :          * uniform order among all csses.  It's guaranteed that all
     161                 :            :          * ->children lists are in the ascending order of ->serial_nr and
     162                 :            :          * used to allow interrupting and resuming iterations.
     163                 :            :          */
     164                 :            :         u64 serial_nr;
     165                 :            : 
     166                 :            :         /*
     167                 :            :          * Incremented by online self and children.  Used to guarantee that
     168                 :            :          * parents are not offlined before their children.
     169                 :            :          */
     170                 :            :         atomic_t online_cnt;
     171                 :            : 
     172                 :            :         /* percpu_ref killing and RCU release */
     173                 :            :         struct work_struct destroy_work;
     174                 :            :         struct rcu_work destroy_rwork;
     175                 :            : 
     176                 :            :         /*
     177                 :            :          * PI: the parent css.  Placed here for cache proximity to following
     178                 :            :          * fields of the containing structure.
     179                 :            :          */
     180                 :            :         struct cgroup_subsys_state *parent;
     181                 :            : };
     182                 :            : 
     183                 :            : /*
     184                 :            :  * A css_set is a structure holding pointers to a set of
     185                 :            :  * cgroup_subsys_state objects. This saves space in the task struct
     186                 :            :  * object and speeds up fork()/exit(), since a single inc/dec and a
     187                 :            :  * list_add()/del() can bump the reference count on the entire cgroup
     188                 :            :  * set for a task.
     189                 :            :  */
     190                 :            : struct css_set {
     191                 :            :         /*
     192                 :            :          * Set of subsystem states, one for each subsystem. This array is
     193                 :            :          * immutable after creation apart from the init_css_set during
     194                 :            :          * subsystem registration (at boot time).
     195                 :            :          */
     196                 :            :         struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
     197                 :            : 
     198                 :            :         /* reference count */
     199                 :            :         refcount_t refcount;
     200                 :            : 
     201                 :            :         /*
     202                 :            :          * For a domain cgroup, the following points to self.  If threaded,
     203                 :            :          * to the matching cset of the nearest domain ancestor.  The
     204                 :            :          * dom_cset provides access to the domain cgroup and its csses to
     205                 :            :          * which domain level resource consumptions should be charged.
     206                 :            :          */
     207                 :            :         struct css_set *dom_cset;
     208                 :            : 
     209                 :            :         /* the default cgroup associated with this css_set */
     210                 :            :         struct cgroup *dfl_cgrp;
     211                 :            : 
     212                 :            :         /* internal task count, protected by css_set_lock */
     213                 :            :         int nr_tasks;
     214                 :            : 
     215                 :            :         /*
     216                 :            :          * Lists running through all tasks using this cgroup group.
     217                 :            :          * mg_tasks lists tasks which belong to this cset but are in the
     218                 :            :          * process of being migrated out or in.  Protected by
     219                 :            :          * css_set_rwsem, but, during migration, once tasks are moved to
     220                 :            :          * mg_tasks, it can be read safely while holding cgroup_mutex.
     221                 :            :          */
     222                 :            :         struct list_head tasks;
     223                 :            :         struct list_head mg_tasks;
     224                 :            :         struct list_head dying_tasks;
     225                 :            : 
     226                 :            :         /* all css_task_iters currently walking this cset */
     227                 :            :         struct list_head task_iters;
     228                 :            : 
     229                 :            :         /*
     230                 :            :          * On the default hierarhcy, ->subsys[ssid] may point to a css
     231                 :            :          * attached to an ancestor instead of the cgroup this css_set is
     232                 :            :          * associated with.  The following node is anchored at
     233                 :            :          * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
     234                 :            :          * iterate through all css's attached to a given cgroup.
     235                 :            :          */
     236                 :            :         struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
     237                 :            : 
     238                 :            :         /* all threaded csets whose ->dom_cset points to this cset */
     239                 :            :         struct list_head threaded_csets;
     240                 :            :         struct list_head threaded_csets_node;
     241                 :            : 
     242                 :            :         /*
     243                 :            :          * List running through all cgroup groups in the same hash
     244                 :            :          * slot. Protected by css_set_lock
     245                 :            :          */
     246                 :            :         struct hlist_node hlist;
     247                 :            : 
     248                 :            :         /*
     249                 :            :          * List of cgrp_cset_links pointing at cgroups referenced from this
     250                 :            :          * css_set.  Protected by css_set_lock.
     251                 :            :          */
     252                 :            :         struct list_head cgrp_links;
     253                 :            : 
     254                 :            :         /*
     255                 :            :          * List of csets participating in the on-going migration either as
     256                 :            :          * source or destination.  Protected by cgroup_mutex.
     257                 :            :          */
     258                 :            :         struct list_head mg_preload_node;
     259                 :            :         struct list_head mg_node;
     260                 :            : 
     261                 :            :         /*
     262                 :            :          * If this cset is acting as the source of migration the following
     263                 :            :          * two fields are set.  mg_src_cgrp and mg_dst_cgrp are
     264                 :            :          * respectively the source and destination cgroups of the on-going
     265                 :            :          * migration.  mg_dst_cset is the destination cset the target tasks
     266                 :            :          * on this cset should be migrated to.  Protected by cgroup_mutex.
     267                 :            :          */
     268                 :            :         struct cgroup *mg_src_cgrp;
     269                 :            :         struct cgroup *mg_dst_cgrp;
     270                 :            :         struct css_set *mg_dst_cset;
     271                 :            : 
     272                 :            :         /* dead and being drained, ignore for migration */
     273                 :            :         bool dead;
     274                 :            : 
     275                 :            :         /* For RCU-protected deletion */
     276                 :            :         struct rcu_head rcu_head;
     277                 :            : };
     278                 :            : 
     279                 :            : struct cgroup_base_stat {
     280                 :            :         struct task_cputime cputime;
     281                 :            : };
     282                 :            : 
     283                 :            : /*
     284                 :            :  * rstat - cgroup scalable recursive statistics.  Accounting is done
     285                 :            :  * per-cpu in cgroup_rstat_cpu which is then lazily propagated up the
     286                 :            :  * hierarchy on reads.
     287                 :            :  *
     288                 :            :  * When a stat gets updated, the cgroup_rstat_cpu and its ancestors are
     289                 :            :  * linked into the updated tree.  On the following read, propagation only
     290                 :            :  * considers and consumes the updated tree.  This makes reading O(the
     291                 :            :  * number of descendants which have been active since last read) instead of
     292                 :            :  * O(the total number of descendants).
     293                 :            :  *
     294                 :            :  * This is important because there can be a lot of (draining) cgroups which
     295                 :            :  * aren't active and stat may be read frequently.  The combination can
     296                 :            :  * become very expensive.  By propagating selectively, increasing reading
     297                 :            :  * frequency decreases the cost of each read.
     298                 :            :  *
     299                 :            :  * This struct hosts both the fields which implement the above -
     300                 :            :  * updated_children and updated_next - and the fields which track basic
     301                 :            :  * resource statistics on top of it - bsync, bstat and last_bstat.
     302                 :            :  */
     303                 :            : struct cgroup_rstat_cpu {
     304                 :            :         /*
     305                 :            :          * ->bsync protects ->bstat.  These are the only fields which get
     306                 :            :          * updated in the hot path.
     307                 :            :          */
     308                 :            :         struct u64_stats_sync bsync;
     309                 :            :         struct cgroup_base_stat bstat;
     310                 :            : 
     311                 :            :         /*
     312                 :            :          * Snapshots at the last reading.  These are used to calculate the
     313                 :            :          * deltas to propagate to the global counters.
     314                 :            :          */
     315                 :            :         struct cgroup_base_stat last_bstat;
     316                 :            : 
     317                 :            :         /*
     318                 :            :          * Child cgroups with stat updates on this cpu since the last read
     319                 :            :          * are linked on the parent's ->updated_children through
     320                 :            :          * ->updated_next.
     321                 :            :          *
     322                 :            :          * In addition to being more compact, singly-linked list pointing
     323                 :            :          * to the cgroup makes it unnecessary for each per-cpu struct to
     324                 :            :          * point back to the associated cgroup.
     325                 :            :          *
     326                 :            :          * Protected by per-cpu cgroup_rstat_cpu_lock.
     327                 :            :          */
     328                 :            :         struct cgroup *updated_children;        /* terminated by self cgroup */
     329                 :            :         struct cgroup *updated_next;            /* NULL iff not on the list */
     330                 :            : };
     331                 :            : 
     332                 :            : struct cgroup_freezer_state {
     333                 :            :         /* Should the cgroup and its descendants be frozen. */
     334                 :            :         bool freeze;
     335                 :            : 
     336                 :            :         /* Should the cgroup actually be frozen? */
     337                 :            :         int e_freeze;
     338                 :            : 
     339                 :            :         /* Fields below are protected by css_set_lock */
     340                 :            : 
     341                 :            :         /* Number of frozen descendant cgroups */
     342                 :            :         int nr_frozen_descendants;
     343                 :            : 
     344                 :            :         /*
     345                 :            :          * Number of tasks, which are counted as frozen:
     346                 :            :          * frozen, SIGSTOPped, and PTRACEd.
     347                 :            :          */
     348                 :            :         int nr_frozen_tasks;
     349                 :            : };
     350                 :            : 
     351                 :            : struct cgroup {
     352                 :            :         /* self css with NULL ->ss, points back to this cgroup */
     353                 :            :         struct cgroup_subsys_state self;
     354                 :            : 
     355                 :            :         unsigned long flags;            /* "unsigned long" so bitops work */
     356                 :            : 
     357                 :            :         /*
     358                 :            :          * idr allocated in-hierarchy ID.
     359                 :            :          *
     360                 :            :          * ID 0 is not used, the ID of the root cgroup is always 1, and a
     361                 :            :          * new cgroup will be assigned with a smallest available ID.
     362                 :            :          *
     363                 :            :          * Allocating/Removing ID must be protected by cgroup_mutex.
     364                 :            :          */
     365                 :            :         int id;
     366                 :            : 
     367                 :            :         /*
     368                 :            :          * The depth this cgroup is at.  The root is at depth zero and each
     369                 :            :          * step down the hierarchy increments the level.  This along with
     370                 :            :          * ancestor_ids[] can determine whether a given cgroup is a
     371                 :            :          * descendant of another without traversing the hierarchy.
     372                 :            :          */
     373                 :            :         int level;
     374                 :            : 
     375                 :            :         /* Maximum allowed descent tree depth */
     376                 :            :         int max_depth;
     377                 :            : 
     378                 :            :         /*
     379                 :            :          * Keep track of total numbers of visible and dying descent cgroups.
     380                 :            :          * Dying cgroups are cgroups which were deleted by a user,
     381                 :            :          * but are still existing because someone else is holding a reference.
     382                 :            :          * max_descendants is a maximum allowed number of descent cgroups.
     383                 :            :          *
     384                 :            :          * nr_descendants and nr_dying_descendants are protected
     385                 :            :          * by cgroup_mutex and css_set_lock. It's fine to read them holding
     386                 :            :          * any of cgroup_mutex and css_set_lock; for writing both locks
     387                 :            :          * should be held.
     388                 :            :          */
     389                 :            :         int nr_descendants;
     390                 :            :         int nr_dying_descendants;
     391                 :            :         int max_descendants;
     392                 :            : 
     393                 :            :         /*
     394                 :            :          * Each non-empty css_set associated with this cgroup contributes
     395                 :            :          * one to nr_populated_csets.  The counter is zero iff this cgroup
     396                 :            :          * doesn't have any tasks.
     397                 :            :          *
     398                 :            :          * All children which have non-zero nr_populated_csets and/or
     399                 :            :          * nr_populated_children of their own contribute one to either
     400                 :            :          * nr_populated_domain_children or nr_populated_threaded_children
     401                 :            :          * depending on their type.  Each counter is zero iff all cgroups
     402                 :            :          * of the type in the subtree proper don't have any tasks.
     403                 :            :          */
     404                 :            :         int nr_populated_csets;
     405                 :            :         int nr_populated_domain_children;
     406                 :            :         int nr_populated_threaded_children;
     407                 :            : 
     408                 :            :         int nr_threaded_children;       /* # of live threaded child cgroups */
     409                 :            : 
     410                 :            :         struct kernfs_node *kn;         /* cgroup kernfs entry */
     411                 :            :         struct cgroup_file procs_file;  /* handle for "cgroup.procs" */
     412                 :            :         struct cgroup_file events_file; /* handle for "cgroup.events" */
     413                 :            : 
     414                 :            :         /*
     415                 :            :          * The bitmask of subsystems enabled on the child cgroups.
     416                 :            :          * ->subtree_control is the one configured through
     417                 :            :          * "cgroup.subtree_control" while ->child_ss_mask is the effective
     418                 :            :          * one which may have more subsystems enabled.  Controller knobs
     419                 :            :          * are made available iff it's enabled in ->subtree_control.
     420                 :            :          */
     421                 :            :         u16 subtree_control;
     422                 :            :         u16 subtree_ss_mask;
     423                 :            :         u16 old_subtree_control;
     424                 :            :         u16 old_subtree_ss_mask;
     425                 :            : 
     426                 :            :         /* Private pointers for each registered subsystem */
     427                 :            :         struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
     428                 :            : 
     429                 :            :         struct cgroup_root *root;
     430                 :            : 
     431                 :            :         /*
     432                 :            :          * List of cgrp_cset_links pointing at css_sets with tasks in this
     433                 :            :          * cgroup.  Protected by css_set_lock.
     434                 :            :          */
     435                 :            :         struct list_head cset_links;
     436                 :            : 
     437                 :            :         /*
     438                 :            :          * On the default hierarchy, a css_set for a cgroup with some
     439                 :            :          * susbsys disabled will point to css's which are associated with
     440                 :            :          * the closest ancestor which has the subsys enabled.  The
     441                 :            :          * following lists all css_sets which point to this cgroup's css
     442                 :            :          * for the given subsystem.
     443                 :            :          */
     444                 :            :         struct list_head e_csets[CGROUP_SUBSYS_COUNT];
     445                 :            : 
     446                 :            :         /*
     447                 :            :          * If !threaded, self.  If threaded, it points to the nearest
     448                 :            :          * domain ancestor.  Inside a threaded subtree, cgroups are exempt
     449                 :            :          * from process granularity and no-internal-task constraint.
     450                 :            :          * Domain level resource consumptions which aren't tied to a
     451                 :            :          * specific task are charged to the dom_cgrp.
     452                 :            :          */
     453                 :            :         struct cgroup *dom_cgrp;
     454                 :            :         struct cgroup *old_dom_cgrp;            /* used while enabling threaded */
     455                 :            : 
     456                 :            :         /* per-cpu recursive resource statistics */
     457                 :            :         struct cgroup_rstat_cpu __percpu *rstat_cpu;
     458                 :            :         struct list_head rstat_css_list;
     459                 :            : 
     460                 :            :         /* cgroup basic resource statistics */
     461                 :            :         struct cgroup_base_stat pending_bstat;  /* pending from children */
     462                 :            :         struct cgroup_base_stat bstat;
     463                 :            :         struct prev_cputime prev_cputime;       /* for printing out cputime */
     464                 :            : 
     465                 :            :         /*
     466                 :            :          * list of pidlists, up to two for each namespace (one for procs, one
     467                 :            :          * for tasks); created on demand.
     468                 :            :          */
     469                 :            :         struct list_head pidlists;
     470                 :            :         struct mutex pidlist_mutex;
     471                 :            : 
     472                 :            :         /* used to wait for offlining of csses */
     473                 :            :         wait_queue_head_t offline_waitq;
     474                 :            : 
     475                 :            :         /* used to schedule release agent */
     476                 :            :         struct work_struct release_agent_work;
     477                 :            : 
     478                 :            :         /* used to track pressure stalls */
     479                 :            :         struct psi_group psi;
     480                 :            : 
     481                 :            :         /* used to store eBPF programs */
     482                 :            :         struct cgroup_bpf bpf;
     483                 :            : 
     484                 :            :         /* If there is block congestion on this cgroup. */
     485                 :            :         atomic_t congestion_count;
     486                 :            : 
     487                 :            :         /* Used to store internal freezer state */
     488                 :            :         struct cgroup_freezer_state freezer;
     489                 :            : 
     490                 :            :         /* ids of the ancestors at each level including self */
     491                 :            :         int ancestor_ids[];
     492                 :            : };
     493                 :            : 
     494                 :            : /*
     495                 :            :  * A cgroup_root represents the root of a cgroup hierarchy, and may be
     496                 :            :  * associated with a kernfs_root to form an active hierarchy.  This is
     497                 :            :  * internal to cgroup core.  Don't access directly from controllers.
     498                 :            :  */
     499                 :            : struct cgroup_root {
     500                 :            :         struct kernfs_root *kf_root;
     501                 :            : 
     502                 :            :         /* The bitmask of subsystems attached to this hierarchy */
     503                 :            :         unsigned int subsys_mask;
     504                 :            : 
     505                 :            :         /* Unique id for this hierarchy. */
     506                 :            :         int hierarchy_id;
     507                 :            : 
     508                 :            :         /* The root cgroup.  Root is destroyed on its release. */
     509                 :            :         struct cgroup cgrp;
     510                 :            : 
     511                 :            :         /* for cgrp->ancestor_ids[0] */
     512                 :            :         int cgrp_ancestor_id_storage;
     513                 :            : 
     514                 :            :         /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
     515                 :            :         atomic_t nr_cgrps;
     516                 :            : 
     517                 :            :         /* A list running through the active hierarchies */
     518                 :            :         struct list_head root_list;
     519                 :            : 
     520                 :            :         /* Hierarchy-specific flags */
     521                 :            :         unsigned int flags;
     522                 :            : 
     523                 :            :         /* IDs for cgroups in this hierarchy */
     524                 :            :         struct idr cgroup_idr;
     525                 :            : 
     526                 :            :         /* The path to use for release notifications. */
     527                 :            :         char release_agent_path[PATH_MAX];
     528                 :            : 
     529                 :            :         /* The name for this hierarchy - may be empty */
     530                 :            :         char name[MAX_CGROUP_ROOT_NAMELEN];
     531                 :            : };
     532                 :            : 
     533                 :            : /*
     534                 :            :  * struct cftype: handler definitions for cgroup control files
     535                 :            :  *
     536                 :            :  * When reading/writing to a file:
     537                 :            :  *      - the cgroup to use is file->f_path.dentry->d_parent->d_fsdata
     538                 :            :  *      - the 'cftype' of the file is file->f_path.dentry->d_fsdata
     539                 :            :  */
     540                 :            : struct cftype {
     541                 :            :         /*
     542                 :            :          * By convention, the name should begin with the name of the
     543                 :            :          * subsystem, followed by a period.  Zero length string indicates
     544                 :            :          * end of cftype array.
     545                 :            :          */
     546                 :            :         char name[MAX_CFTYPE_NAME];
     547                 :            :         unsigned long private;
     548                 :            : 
     549                 :            :         /*
     550                 :            :          * The maximum length of string, excluding trailing nul, that can
     551                 :            :          * be passed to write.  If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
     552                 :            :          */
     553                 :            :         size_t max_write_len;
     554                 :            : 
     555                 :            :         /* CFTYPE_* flags */
     556                 :            :         unsigned int flags;
     557                 :            : 
     558                 :            :         /*
     559                 :            :          * If non-zero, should contain the offset from the start of css to
     560                 :            :          * a struct cgroup_file field.  cgroup will record the handle of
     561                 :            :          * the created file into it.  The recorded handle can be used as
     562                 :            :          * long as the containing css remains accessible.
     563                 :            :          */
     564                 :            :         unsigned int file_offset;
     565                 :            : 
     566                 :            :         /*
     567                 :            :          * Fields used for internal bookkeeping.  Initialized automatically
     568                 :            :          * during registration.
     569                 :            :          */
     570                 :            :         struct cgroup_subsys *ss;       /* NULL for cgroup core files */
     571                 :            :         struct list_head node;          /* anchored at ss->cfts */
     572                 :            :         struct kernfs_ops *kf_ops;
     573                 :            : 
     574                 :            :         int (*open)(struct kernfs_open_file *of);
     575                 :            :         void (*release)(struct kernfs_open_file *of);
     576                 :            : 
     577                 :            :         /*
     578                 :            :          * read_u64() is a shortcut for the common case of returning a
     579                 :            :          * single integer. Use it in place of read()
     580                 :            :          */
     581                 :            :         u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
     582                 :            :         /*
     583                 :            :          * read_s64() is a signed version of read_u64()
     584                 :            :          */
     585                 :            :         s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
     586                 :            : 
     587                 :            :         /* generic seq_file read interface */
     588                 :            :         int (*seq_show)(struct seq_file *sf, void *v);
     589                 :            : 
     590                 :            :         /* optional ops, implement all or none */
     591                 :            :         void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
     592                 :            :         void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
     593                 :            :         void (*seq_stop)(struct seq_file *sf, void *v);
     594                 :            : 
     595                 :            :         /*
     596                 :            :          * write_u64() is a shortcut for the common case of accepting
     597                 :            :          * a single integer (as parsed by simple_strtoull) from
     598                 :            :          * userspace. Use in place of write(); return 0 or error.
     599                 :            :          */
     600                 :            :         int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
     601                 :            :                          u64 val);
     602                 :            :         /*
     603                 :            :          * write_s64() is a signed version of write_u64()
     604                 :            :          */
     605                 :            :         int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
     606                 :            :                          s64 val);
     607                 :            : 
     608                 :            :         /*
     609                 :            :          * write() is the generic write callback which maps directly to
     610                 :            :          * kernfs write operation and overrides all other operations.
     611                 :            :          * Maximum write size is determined by ->max_write_len.  Use
     612                 :            :          * of_css/cft() to access the associated css and cft.
     613                 :            :          */
     614                 :            :         ssize_t (*write)(struct kernfs_open_file *of,
     615                 :            :                          char *buf, size_t nbytes, loff_t off);
     616                 :            : 
     617                 :            :         __poll_t (*poll)(struct kernfs_open_file *of,
     618                 :            :                          struct poll_table_struct *pt);
     619                 :            : 
     620                 :            : #ifdef CONFIG_DEBUG_LOCK_ALLOC
     621                 :            :         struct lock_class_key   lockdep_key;
     622                 :            : #endif
     623                 :            : };
     624                 :            : 
     625                 :            : /*
     626                 :            :  * Control Group subsystem type.
     627                 :            :  * See Documentation/admin-guide/cgroup-v1/cgroups.rst for details
     628                 :            :  */
     629                 :            : struct cgroup_subsys {
     630                 :            :         struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
     631                 :            :         int (*css_online)(struct cgroup_subsys_state *css);
     632                 :            :         void (*css_offline)(struct cgroup_subsys_state *css);
     633                 :            :         void (*css_released)(struct cgroup_subsys_state *css);
     634                 :            :         void (*css_free)(struct cgroup_subsys_state *css);
     635                 :            :         void (*css_reset)(struct cgroup_subsys_state *css);
     636                 :            :         void (*css_rstat_flush)(struct cgroup_subsys_state *css, int cpu);
     637                 :            :         int (*css_extra_stat_show)(struct seq_file *seq,
     638                 :            :                                    struct cgroup_subsys_state *css);
     639                 :            : 
     640                 :            :         int (*can_attach)(struct cgroup_taskset *tset);
     641                 :            :         void (*cancel_attach)(struct cgroup_taskset *tset);
     642                 :            :         void (*attach)(struct cgroup_taskset *tset);
     643                 :            :         void (*post_attach)(void);
     644                 :            :         int (*can_fork)(struct task_struct *task);
     645                 :            :         void (*cancel_fork)(struct task_struct *task);
     646                 :            :         void (*fork)(struct task_struct *task);
     647                 :            :         void (*exit)(struct task_struct *task);
     648                 :            :         void (*release)(struct task_struct *task);
     649                 :            :         void (*bind)(struct cgroup_subsys_state *root_css);
     650                 :            : 
     651                 :            :         bool early_init:1;
     652                 :            : 
     653                 :            :         /*
     654                 :            :          * If %true, the controller, on the default hierarchy, doesn't show
     655                 :            :          * up in "cgroup.controllers" or "cgroup.subtree_control", is
     656                 :            :          * implicitly enabled on all cgroups on the default hierarchy, and
     657                 :            :          * bypasses the "no internal process" constraint.  This is for
     658                 :            :          * utility type controllers which is transparent to userland.
     659                 :            :          *
     660                 :            :          * An implicit controller can be stolen from the default hierarchy
     661                 :            :          * anytime and thus must be okay with offline csses from previous
     662                 :            :          * hierarchies coexisting with csses for the current one.
     663                 :            :          */
     664                 :            :         bool implicit_on_dfl:1;
     665                 :            : 
     666                 :            :         /*
     667                 :            :          * If %true, the controller, supports threaded mode on the default
     668                 :            :          * hierarchy.  In a threaded subtree, both process granularity and
     669                 :            :          * no-internal-process constraint are ignored and a threaded
     670                 :            :          * controllers should be able to handle that.
     671                 :            :          *
     672                 :            :          * Note that as an implicit controller is automatically enabled on
     673                 :            :          * all cgroups on the default hierarchy, it should also be
     674                 :            :          * threaded.  implicit && !threaded is not supported.
     675                 :            :          */
     676                 :            :         bool threaded:1;
     677                 :            : 
     678                 :            :         /*
     679                 :            :          * If %false, this subsystem is properly hierarchical -
     680                 :            :          * configuration, resource accounting and restriction on a parent
     681                 :            :          * cgroup cover those of its children.  If %true, hierarchy support
     682                 :            :          * is broken in some ways - some subsystems ignore hierarchy
     683                 :            :          * completely while others are only implemented half-way.
     684                 :            :          *
     685                 :            :          * It's now disallowed to create nested cgroups if the subsystem is
     686                 :            :          * broken and cgroup core will emit a warning message on such
     687                 :            :          * cases.  Eventually, all subsystems will be made properly
     688                 :            :          * hierarchical and this will go away.
     689                 :            :          */
     690                 :            :         bool broken_hierarchy:1;
     691                 :            :         bool warned_broken_hierarchy:1;
     692                 :            : 
     693                 :            :         /* the following two fields are initialized automtically during boot */
     694                 :            :         int id;
     695                 :            :         const char *name;
     696                 :            : 
     697                 :            :         /* optional, initialized automatically during boot if not set */
     698                 :            :         const char *legacy_name;
     699                 :            : 
     700                 :            :         /* link to parent, protected by cgroup_lock() */
     701                 :            :         struct cgroup_root *root;
     702                 :            : 
     703                 :            :         /* idr for css->id */
     704                 :            :         struct idr css_idr;
     705                 :            : 
     706                 :            :         /*
     707                 :            :          * List of cftypes.  Each entry is the first entry of an array
     708                 :            :          * terminated by zero length name.
     709                 :            :          */
     710                 :            :         struct list_head cfts;
     711                 :            : 
     712                 :            :         /*
     713                 :            :          * Base cftypes which are automatically registered.  The two can
     714                 :            :          * point to the same array.
     715                 :            :          */
     716                 :            :         struct cftype *dfl_cftypes;     /* for the default hierarchy */
     717                 :            :         struct cftype *legacy_cftypes;  /* for the legacy hierarchies */
     718                 :            : 
     719                 :            :         /*
     720                 :            :          * A subsystem may depend on other subsystems.  When such subsystem
     721                 :            :          * is enabled on a cgroup, the depended-upon subsystems are enabled
     722                 :            :          * together if available.  Subsystems enabled due to dependency are
     723                 :            :          * not visible to userland until explicitly enabled.  The following
     724                 :            :          * specifies the mask of subsystems that this one depends on.
     725                 :            :          */
     726                 :            :         unsigned int depends_on;
     727                 :            : };
     728                 :            : 
     729                 :            : extern struct percpu_rw_semaphore cgroup_threadgroup_rwsem;
     730                 :            : 
     731                 :            : /**
     732                 :            :  * cgroup_threadgroup_change_begin - threadgroup exclusion for cgroups
     733                 :            :  * @tsk: target task
     734                 :            :  *
     735                 :            :  * Allows cgroup operations to synchronize against threadgroup changes
     736                 :            :  * using a percpu_rw_semaphore.
     737                 :            :  */
     738                 :            : static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk)
     739                 :            : {
     740                 :          3 :         percpu_down_read(&cgroup_threadgroup_rwsem);
     741                 :            : }
     742                 :            : 
     743                 :            : /**
     744                 :            :  * cgroup_threadgroup_change_end - threadgroup exclusion for cgroups
     745                 :            :  * @tsk: target task
     746                 :            :  *
     747                 :            :  * Counterpart of cgroup_threadcgroup_change_begin().
     748                 :            :  */
     749                 :            : static inline void cgroup_threadgroup_change_end(struct task_struct *tsk)
     750                 :            : {
     751                 :          3 :         percpu_up_read(&cgroup_threadgroup_rwsem);
     752                 :            : }
     753                 :            : 
     754                 :            : #else   /* CONFIG_CGROUPS */
     755                 :            : 
     756                 :            : #define CGROUP_SUBSYS_COUNT 0
     757                 :            : 
     758                 :            : static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk)
     759                 :            : {
     760                 :            :         might_sleep();
     761                 :            : }
     762                 :            : 
     763                 :            : static inline void cgroup_threadgroup_change_end(struct task_struct *tsk) {}
     764                 :            : 
     765                 :            : #endif  /* CONFIG_CGROUPS */
     766                 :            : 
     767                 :            : #ifdef CONFIG_SOCK_CGROUP_DATA
     768                 :            : 
     769                 :            : /*
     770                 :            :  * sock_cgroup_data is embedded at sock->sk_cgrp_data and contains
     771                 :            :  * per-socket cgroup information except for memcg association.
     772                 :            :  *
     773                 :            :  * On legacy hierarchies, net_prio and net_cls controllers directly set
     774                 :            :  * attributes on each sock which can then be tested by the network layer.
     775                 :            :  * On the default hierarchy, each sock is associated with the cgroup it was
     776                 :            :  * created in and the networking layer can match the cgroup directly.
     777                 :            :  *
     778                 :            :  * To avoid carrying all three cgroup related fields separately in sock,
     779                 :            :  * sock_cgroup_data overloads (prioidx, classid) and the cgroup pointer.
     780                 :            :  * On boot, sock_cgroup_data records the cgroup that the sock was created
     781                 :            :  * in so that cgroup2 matches can be made; however, once either net_prio or
     782                 :            :  * net_cls starts being used, the area is overriden to carry prioidx and/or
     783                 :            :  * classid.  The two modes are distinguished by whether the lowest bit is
     784                 :            :  * set.  Clear bit indicates cgroup pointer while set bit prioidx and
     785                 :            :  * classid.
     786                 :            :  *
     787                 :            :  * While userland may start using net_prio or net_cls at any time, once
     788                 :            :  * either is used, cgroup2 matching no longer works.  There is no reason to
     789                 :            :  * mix the two and this is in line with how legacy and v2 compatibility is
     790                 :            :  * handled.  On mode switch, cgroup references which are already being
     791                 :            :  * pointed to by socks may be leaked.  While this can be remedied by adding
     792                 :            :  * synchronization around sock_cgroup_data, given that the number of leaked
     793                 :            :  * cgroups is bound and highly unlikely to be high, this seems to be the
     794                 :            :  * better trade-off.
     795                 :            :  */
     796                 :            : struct sock_cgroup_data {
     797                 :            :         union {
     798                 :            : #ifdef __LITTLE_ENDIAN
     799                 :            :                 struct {
     800                 :            :                         u8      is_data : 1;
     801                 :            :                         u8      no_refcnt : 1;
     802                 :            :                         u8      unused : 6;
     803                 :            :                         u8      padding;
     804                 :            :                         u16     prioidx;
     805                 :            :                         u32     classid;
     806                 :            :                 } __packed;
     807                 :            : #else
     808                 :            :                 struct {
     809                 :            :                         u32     classid;
     810                 :            :                         u16     prioidx;
     811                 :            :                         u8      padding;
     812                 :            :                         u8      unused : 6;
     813                 :            :                         u8      no_refcnt : 1;
     814                 :            :                         u8      is_data : 1;
     815                 :            :                 } __packed;
     816                 :            : #endif
     817                 :            :                 u64             val;
     818                 :            :         };
     819                 :            : };
     820                 :            : 
     821                 :            : /*
     822                 :            :  * There's a theoretical window where the following accessors race with
     823                 :            :  * updaters and return part of the previous pointer as the prioidx or
     824                 :            :  * classid.  Such races are short-lived and the result isn't critical.
     825                 :            :  */
     826                 :            : static inline u16 sock_cgroup_prioidx(const struct sock_cgroup_data *skcd)
     827                 :            : {
     828                 :            :         /* fallback to 1 which is always the ID of the root cgroup */
     829                 :          3 :         return (skcd->is_data & 1) ? skcd->prioidx : 1;
     830                 :            : }
     831                 :            : 
     832                 :            : static inline u32 sock_cgroup_classid(const struct sock_cgroup_data *skcd)
     833                 :            : {
     834                 :            :         /* fallback to 0 which is the unconfigured default classid */
     835                 :          3 :         return (skcd->is_data & 1) ? skcd->classid : 0;
     836                 :            : }
     837                 :            : 
     838                 :            : /*
     839                 :            :  * If invoked concurrently, the updaters may clobber each other.  The
     840                 :            :  * caller is responsible for synchronization.
     841                 :            :  */
     842                 :          3 : static inline void sock_cgroup_set_prioidx(struct sock_cgroup_data *skcd,
     843                 :            :                                            u16 prioidx)
     844                 :            : {
     845                 :          3 :         struct sock_cgroup_data skcd_buf = {{ .val = READ_ONCE(skcd->val) }};
     846                 :            : 
     847                 :          3 :         if (sock_cgroup_prioidx(&skcd_buf) == prioidx)
     848                 :          3 :                 return;
     849                 :            : 
     850                 :          0 :         if (!(skcd_buf.is_data & 1)) {
     851                 :          0 :                 skcd_buf.val = 0;
     852                 :          0 :                 skcd_buf.is_data = 1;
     853                 :            :         }
     854                 :            : 
     855                 :          0 :         skcd_buf.prioidx = prioidx;
     856                 :          0 :         WRITE_ONCE(skcd->val, skcd_buf.val); /* see sock_cgroup_ptr() */
     857                 :            : }
     858                 :            : 
     859                 :          3 : static inline void sock_cgroup_set_classid(struct sock_cgroup_data *skcd,
     860                 :            :                                            u32 classid)
     861                 :            : {
     862                 :          3 :         struct sock_cgroup_data skcd_buf = {{ .val = READ_ONCE(skcd->val) }};
     863                 :            : 
     864                 :          3 :         if (sock_cgroup_classid(&skcd_buf) == classid)
     865                 :          3 :                 return;
     866                 :            : 
     867                 :          0 :         if (!(skcd_buf.is_data & 1)) {
     868                 :          0 :                 skcd_buf.val = 0;
     869                 :          0 :                 skcd_buf.is_data = 1;
     870                 :            :         }
     871                 :            : 
     872                 :          0 :         skcd_buf.classid = classid;
     873                 :          0 :         WRITE_ONCE(skcd->val, skcd_buf.val); /* see sock_cgroup_ptr() */
     874                 :            : }
     875                 :            : 
     876                 :            : #else   /* CONFIG_SOCK_CGROUP_DATA */
     877                 :            : 
     878                 :            : struct sock_cgroup_data {
     879                 :            : };
     880                 :            : 
     881                 :            : #endif  /* CONFIG_SOCK_CGROUP_DATA */
     882                 :            : 
     883                 :            : #endif  /* _LINUX_CGROUP_DEFS_H */