LCOV - code coverage report
Current view: top level - include/linux - cgroup.h (source / functions) Hit Total Coverage
Test: Real Lines: 52 80 65.0 %
Date: 2020-10-17 15:46:16 Functions: 0 12 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_CGROUP_H
       3                 :            : #define _LINUX_CGROUP_H
       4                 :            : /*
       5                 :            :  *  cgroup interface
       6                 :            :  *
       7                 :            :  *  Copyright (C) 2003 BULL SA
       8                 :            :  *  Copyright (C) 2004-2006 Silicon Graphics, Inc.
       9                 :            :  *
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/sched.h>
      13                 :            : #include <linux/cpumask.h>
      14                 :            : #include <linux/nodemask.h>
      15                 :            : #include <linux/rculist.h>
      16                 :            : #include <linux/cgroupstats.h>
      17                 :            : #include <linux/fs.h>
      18                 :            : #include <linux/seq_file.h>
      19                 :            : #include <linux/kernfs.h>
      20                 :            : #include <linux/jump_label.h>
      21                 :            : #include <linux/types.h>
      22                 :            : #include <linux/ns_common.h>
      23                 :            : #include <linux/nsproxy.h>
      24                 :            : #include <linux/user_namespace.h>
      25                 :            : #include <linux/refcount.h>
      26                 :            : #include <linux/kernel_stat.h>
      27                 :            : 
      28                 :            : #include <linux/cgroup-defs.h>
      29                 :            : 
      30                 :            : #ifdef CONFIG_CGROUPS
      31                 :            : 
      32                 :            : /*
      33                 :            :  * All weight knobs on the default hierarhcy should use the following min,
      34                 :            :  * default and max values.  The default value is the logarithmic center of
      35                 :            :  * MIN and MAX and allows 100x to be expressed in both directions.
      36                 :            :  */
      37                 :            : #define CGROUP_WEIGHT_MIN               1
      38                 :            : #define CGROUP_WEIGHT_DFL               100
      39                 :            : #define CGROUP_WEIGHT_MAX               10000
      40                 :            : 
      41                 :            : /* walk only threadgroup leaders */
      42                 :            : #define CSS_TASK_ITER_PROCS             (1U << 0)
      43                 :            : /* walk all threaded css_sets in the domain */
      44                 :            : #define CSS_TASK_ITER_THREADED          (1U << 1)
      45                 :            : 
      46                 :            : /* internal flags */
      47                 :            : #define CSS_TASK_ITER_SKIPPED           (1U << 16)
      48                 :            : 
      49                 :            : /* a css_task_iter should be treated as an opaque object */
      50                 :            : struct css_task_iter {
      51                 :            :         struct cgroup_subsys            *ss;
      52                 :            :         unsigned int                    flags;
      53                 :            : 
      54                 :            :         struct list_head                *cset_pos;
      55                 :            :         struct list_head                *cset_head;
      56                 :            : 
      57                 :            :         struct list_head                *tcset_pos;
      58                 :            :         struct list_head                *tcset_head;
      59                 :            : 
      60                 :            :         struct list_head                *task_pos;
      61                 :            :         struct list_head                *tasks_head;
      62                 :            :         struct list_head                *mg_tasks_head;
      63                 :            :         struct list_head                *dying_tasks_head;
      64                 :            : 
      65                 :            :         struct list_head                *cur_tasks_head;
      66                 :            :         struct css_set                  *cur_cset;
      67                 :            :         struct css_set                  *cur_dcset;
      68                 :            :         struct task_struct              *cur_task;
      69                 :            :         struct list_head                iters_node;     /* css_set->task_iters */
      70                 :            : };
      71                 :            : 
      72                 :            : extern struct cgroup_root cgrp_dfl_root;
      73                 :            : extern struct css_set init_css_set;
      74                 :            : 
      75                 :            : #define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
      76                 :            : #include <linux/cgroup_subsys.h>
      77                 :            : #undef SUBSYS
      78                 :            : 
      79                 :            : #define SUBSYS(_x)                                                              \
      80                 :            :         extern struct static_key_true _x ## _cgrp_subsys_enabled_key;           \
      81                 :            :         extern struct static_key_true _x ## _cgrp_subsys_on_dfl_key;
      82                 :            : #include <linux/cgroup_subsys.h>
      83                 :            : #undef SUBSYS
      84                 :            : 
      85                 :            : /**
      86                 :            :  * cgroup_subsys_enabled - fast test on whether a subsys is enabled
      87                 :            :  * @ss: subsystem in question
      88                 :            :  */
      89                 :            : #define cgroup_subsys_enabled(ss)                                               \
      90                 :            :         static_branch_likely(&ss ## _enabled_key)
      91                 :            : 
      92                 :            : /**
      93                 :            :  * cgroup_subsys_on_dfl - fast test on whether a subsys is on default hierarchy
      94                 :            :  * @ss: subsystem in question
      95                 :            :  */
      96                 :            : #define cgroup_subsys_on_dfl(ss)                                                \
      97                 :            :         static_branch_likely(&ss ## _on_dfl_key)
      98                 :            : 
      99                 :            : bool css_has_online_children(struct cgroup_subsys_state *css);
     100                 :            : struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
     101                 :            : struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgroup,
     102                 :            :                                          struct cgroup_subsys *ss);
     103                 :            : struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
     104                 :            :                                              struct cgroup_subsys *ss);
     105                 :            : struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
     106                 :            :                                                        struct cgroup_subsys *ss);
     107                 :            : 
     108                 :            : struct cgroup *cgroup_get_from_path(const char *path);
     109                 :            : struct cgroup *cgroup_get_from_fd(int fd);
     110                 :            : 
     111                 :            : int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
     112                 :            : int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
     113                 :            : 
     114                 :            : int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
     115                 :            : int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
     116                 :            : int cgroup_rm_cftypes(struct cftype *cfts);
     117                 :            : void cgroup_file_notify(struct cgroup_file *cfile);
     118                 :            : 
     119                 :            : int task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
     120                 :            : int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry);
     121                 :            : int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
     122                 :            :                      struct pid *pid, struct task_struct *tsk);
     123                 :            : 
     124                 :            : void cgroup_fork(struct task_struct *p);
     125                 :            : extern int cgroup_can_fork(struct task_struct *p);
     126                 :            : extern void cgroup_cancel_fork(struct task_struct *p);
     127                 :            : extern void cgroup_post_fork(struct task_struct *p);
     128                 :            : void cgroup_exit(struct task_struct *p);
     129                 :            : void cgroup_release(struct task_struct *p);
     130                 :            : void cgroup_free(struct task_struct *p);
     131                 :            : 
     132                 :            : int cgroup_init_early(void);
     133                 :            : int cgroup_init(void);
     134                 :            : 
     135                 :            : int cgroup_parse_float(const char *input, unsigned dec_shift, s64 *v);
     136                 :            : 
     137                 :            : /*
     138                 :            :  * Iteration helpers and macros.
     139                 :            :  */
     140                 :            : 
     141                 :            : struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
     142                 :            :                                            struct cgroup_subsys_state *parent);
     143                 :            : struct cgroup_subsys_state *css_next_descendant_pre(struct cgroup_subsys_state *pos,
     144                 :            :                                                     struct cgroup_subsys_state *css);
     145                 :            : struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state *pos);
     146                 :            : struct cgroup_subsys_state *css_next_descendant_post(struct cgroup_subsys_state *pos,
     147                 :            :                                                      struct cgroup_subsys_state *css);
     148                 :            : 
     149                 :            : struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset,
     150                 :            :                                          struct cgroup_subsys_state **dst_cssp);
     151                 :            : struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset,
     152                 :            :                                         struct cgroup_subsys_state **dst_cssp);
     153                 :            : 
     154                 :            : void cgroup_enable_task_cg_lists(void);
     155                 :            : void css_task_iter_start(struct cgroup_subsys_state *css, unsigned int flags,
     156                 :            :                          struct css_task_iter *it);
     157                 :            : struct task_struct *css_task_iter_next(struct css_task_iter *it);
     158                 :            : void css_task_iter_end(struct css_task_iter *it);
     159                 :            : 
     160                 :            : /**
     161                 :            :  * css_for_each_child - iterate through children of a css
     162                 :            :  * @pos: the css * to use as the loop cursor
     163                 :            :  * @parent: css whose children to walk
     164                 :            :  *
     165                 :            :  * Walk @parent's children.  Must be called under rcu_read_lock().
     166                 :            :  *
     167                 :            :  * If a subsystem synchronizes ->css_online() and the start of iteration, a
     168                 :            :  * css which finished ->css_online() is guaranteed to be visible in the
     169                 :            :  * future iterations and will stay visible until the last reference is put.
     170                 :            :  * A css which hasn't finished ->css_online() or already finished
     171                 :            :  * ->css_offline() may show up during traversal.  It's each subsystem's
     172                 :            :  * responsibility to synchronize against on/offlining.
     173                 :            :  *
     174                 :            :  * It is allowed to temporarily drop RCU read lock during iteration.  The
     175                 :            :  * caller is responsible for ensuring that @pos remains accessible until
     176                 :            :  * the start of the next iteration by, for example, bumping the css refcnt.
     177                 :            :  */
     178                 :            : #define css_for_each_child(pos, parent)                                 \
     179                 :            :         for ((pos) = css_next_child(NULL, (parent)); (pos);             \
     180                 :            :              (pos) = css_next_child((pos), (parent)))
     181                 :            : 
     182                 :            : /**
     183                 :            :  * css_for_each_descendant_pre - pre-order walk of a css's descendants
     184                 :            :  * @pos: the css * to use as the loop cursor
     185                 :            :  * @root: css whose descendants to walk
     186                 :            :  *
     187                 :            :  * Walk @root's descendants.  @root is included in the iteration and the
     188                 :            :  * first node to be visited.  Must be called under rcu_read_lock().
     189                 :            :  *
     190                 :            :  * If a subsystem synchronizes ->css_online() and the start of iteration, a
     191                 :            :  * css which finished ->css_online() is guaranteed to be visible in the
     192                 :            :  * future iterations and will stay visible until the last reference is put.
     193                 :            :  * A css which hasn't finished ->css_online() or already finished
     194                 :            :  * ->css_offline() may show up during traversal.  It's each subsystem's
     195                 :            :  * responsibility to synchronize against on/offlining.
     196                 :            :  *
     197                 :            :  * For example, the following guarantees that a descendant can't escape
     198                 :            :  * state updates of its ancestors.
     199                 :            :  *
     200                 :            :  * my_online(@css)
     201                 :            :  * {
     202                 :            :  *      Lock @css's parent and @css;
     203                 :            :  *      Inherit state from the parent;
     204                 :            :  *      Unlock both.
     205                 :            :  * }
     206                 :            :  *
     207                 :            :  * my_update_state(@css)
     208                 :            :  * {
     209                 :            :  *      css_for_each_descendant_pre(@pos, @css) {
     210                 :            :  *              Lock @pos;
     211                 :            :  *              if (@pos == @css)
     212                 :            :  *                      Update @css's state;
     213                 :            :  *              else
     214                 :            :  *                      Verify @pos is alive and inherit state from its parent;
     215                 :            :  *              Unlock @pos;
     216                 :            :  *      }
     217                 :            :  * }
     218                 :            :  *
     219                 :            :  * As long as the inheriting step, including checking the parent state, is
     220                 :            :  * enclosed inside @pos locking, double-locking the parent isn't necessary
     221                 :            :  * while inheriting.  The state update to the parent is guaranteed to be
     222                 :            :  * visible by walking order and, as long as inheriting operations to the
     223                 :            :  * same @pos are atomic to each other, multiple updates racing each other
     224                 :            :  * still result in the correct state.  It's guaranateed that at least one
     225                 :            :  * inheritance happens for any css after the latest update to its parent.
     226                 :            :  *
     227                 :            :  * If checking parent's state requires locking the parent, each inheriting
     228                 :            :  * iteration should lock and unlock both @pos->parent and @pos.
     229                 :            :  *
     230                 :            :  * Alternatively, a subsystem may choose to use a single global lock to
     231                 :            :  * synchronize ->css_online() and ->css_offline() against tree-walking
     232                 :            :  * operations.
     233                 :            :  *
     234                 :            :  * It is allowed to temporarily drop RCU read lock during iteration.  The
     235                 :            :  * caller is responsible for ensuring that @pos remains accessible until
     236                 :            :  * the start of the next iteration by, for example, bumping the css refcnt.
     237                 :            :  */
     238                 :            : #define css_for_each_descendant_pre(pos, css)                           \
     239                 :            :         for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);       \
     240                 :            :              (pos) = css_next_descendant_pre((pos), (css)))
     241                 :            : 
     242                 :            : /**
     243                 :            :  * css_for_each_descendant_post - post-order walk of a css's descendants
     244                 :            :  * @pos: the css * to use as the loop cursor
     245                 :            :  * @css: css whose descendants to walk
     246                 :            :  *
     247                 :            :  * Similar to css_for_each_descendant_pre() but performs post-order
     248                 :            :  * traversal instead.  @root is included in the iteration and the last
     249                 :            :  * node to be visited.
     250                 :            :  *
     251                 :            :  * If a subsystem synchronizes ->css_online() and the start of iteration, a
     252                 :            :  * css which finished ->css_online() is guaranteed to be visible in the
     253                 :            :  * future iterations and will stay visible until the last reference is put.
     254                 :            :  * A css which hasn't finished ->css_online() or already finished
     255                 :            :  * ->css_offline() may show up during traversal.  It's each subsystem's
     256                 :            :  * responsibility to synchronize against on/offlining.
     257                 :            :  *
     258                 :            :  * Note that the walk visibility guarantee example described in pre-order
     259                 :            :  * walk doesn't apply the same to post-order walks.
     260                 :            :  */
     261                 :            : #define css_for_each_descendant_post(pos, css)                          \
     262                 :            :         for ((pos) = css_next_descendant_post(NULL, (css)); (pos);      \
     263                 :            :              (pos) = css_next_descendant_post((pos), (css)))
     264                 :            : 
     265                 :            : /**
     266                 :            :  * cgroup_taskset_for_each - iterate cgroup_taskset
     267                 :            :  * @task: the loop cursor
     268                 :            :  * @dst_css: the destination css
     269                 :            :  * @tset: taskset to iterate
     270                 :            :  *
     271                 :            :  * @tset may contain multiple tasks and they may belong to multiple
     272                 :            :  * processes.
     273                 :            :  *
     274                 :            :  * On the v2 hierarchy, there may be tasks from multiple processes and they
     275                 :            :  * may not share the source or destination csses.
     276                 :            :  *
     277                 :            :  * On traditional hierarchies, when there are multiple tasks in @tset, if a
     278                 :            :  * task of a process is in @tset, all tasks of the process are in @tset.
     279                 :            :  * Also, all are guaranteed to share the same source and destination csses.
     280                 :            :  *
     281                 :            :  * Iteration is not in any specific order.
     282                 :            :  */
     283                 :            : #define cgroup_taskset_for_each(task, dst_css, tset)                    \
     284                 :            :         for ((task) = cgroup_taskset_first((tset), &(dst_css));             \
     285                 :            :              (task);                                                    \
     286                 :            :              (task) = cgroup_taskset_next((tset), &(dst_css)))
     287                 :            : 
     288                 :            : /**
     289                 :            :  * cgroup_taskset_for_each_leader - iterate group leaders in a cgroup_taskset
     290                 :            :  * @leader: the loop cursor
     291                 :            :  * @dst_css: the destination css
     292                 :            :  * @tset: taskset to iterate
     293                 :            :  *
     294                 :            :  * Iterate threadgroup leaders of @tset.  For single-task migrations, @tset
     295                 :            :  * may not contain any.
     296                 :            :  */
     297                 :            : #define cgroup_taskset_for_each_leader(leader, dst_css, tset)           \
     298                 :            :         for ((leader) = cgroup_taskset_first((tset), &(dst_css));   \
     299                 :            :              (leader);                                                  \
     300                 :            :              (leader) = cgroup_taskset_next((tset), &(dst_css)))    \
     301                 :            :                 if ((leader) != (leader)->group_leader)                      \
     302                 :            :                         ;                                               \
     303                 :            :                 else
     304                 :            : 
     305                 :            : /*
     306                 :            :  * Inline functions.
     307                 :            :  */
     308                 :            : 
     309                 :            : /**
     310                 :            :  * css_get - obtain a reference on the specified css
     311                 :            :  * @css: target css
     312                 :            :  *
     313                 :            :  * The caller must already have a reference.
     314                 :            :  */
     315                 :            : static inline void css_get(struct cgroup_subsys_state *css)
     316                 :            : {
     317                 :          3 :         if (!(css->flags & CSS_NO_REF))
     318                 :          3 :                 percpu_ref_get(&css->refcnt);
     319                 :            : }
     320                 :            : 
     321                 :            : /**
     322                 :            :  * css_get_many - obtain references on the specified css
     323                 :            :  * @css: target css
     324                 :            :  * @n: number of references to get
     325                 :            :  *
     326                 :            :  * The caller must already have a reference.
     327                 :            :  */
     328                 :            : static inline void css_get_many(struct cgroup_subsys_state *css, unsigned int n)
     329                 :            : {
     330                 :          0 :         if (!(css->flags & CSS_NO_REF))
     331                 :          0 :                 percpu_ref_get_many(&css->refcnt, n);
     332                 :            : }
     333                 :            : 
     334                 :            : /**
     335                 :            :  * css_tryget - try to obtain a reference on the specified css
     336                 :            :  * @css: target css
     337                 :            :  *
     338                 :            :  * Obtain a reference on @css unless it already has reached zero and is
     339                 :            :  * being released.  This function doesn't care whether @css is on or
     340                 :            :  * offline.  The caller naturally needs to ensure that @css is accessible
     341                 :            :  * but doesn't have to be holding a reference on it - IOW, RCU protected
     342                 :            :  * access is good enough for this function.  Returns %true if a reference
     343                 :            :  * count was successfully obtained; %false otherwise.
     344                 :            :  */
     345                 :            : static inline bool css_tryget(struct cgroup_subsys_state *css)
     346                 :            : {
     347                 :          3 :         if (!(css->flags & CSS_NO_REF))
     348                 :          3 :                 return percpu_ref_tryget(&css->refcnt);
     349                 :            :         return true;
     350                 :            : }
     351                 :            : 
     352                 :            : /**
     353                 :            :  * css_tryget_online - try to obtain a reference on the specified css if online
     354                 :            :  * @css: target css
     355                 :            :  *
     356                 :            :  * Obtain a reference on @css if it's online.  The caller naturally needs
     357                 :            :  * to ensure that @css is accessible but doesn't have to be holding a
     358                 :            :  * reference on it - IOW, RCU protected access is good enough for this
     359                 :            :  * function.  Returns %true if a reference count was successfully obtained;
     360                 :            :  * %false otherwise.
     361                 :            :  */
     362                 :          0 : static inline bool css_tryget_online(struct cgroup_subsys_state *css)
     363                 :            : {
     364                 :          3 :         if (!(css->flags & CSS_NO_REF))
     365                 :          3 :                 return percpu_ref_tryget_live(&css->refcnt);
     366                 :            :         return true;
     367                 :            : }
     368                 :            : 
     369                 :            : /**
     370                 :            :  * css_is_dying - test whether the specified css is dying
     371                 :            :  * @css: target css
     372                 :            :  *
     373                 :            :  * Test whether @css is in the process of offlining or already offline.  In
     374                 :            :  * most cases, ->css_online() and ->css_offline() callbacks should be
     375                 :            :  * enough; however, the actual offline operations are RCU delayed and this
     376                 :            :  * test returns %true also when @css is scheduled to be offlined.
     377                 :            :  *
     378                 :            :  * This is useful, for example, when the use case requires synchronous
     379                 :            :  * behavior with respect to cgroup removal.  cgroup removal schedules css
     380                 :            :  * offlining but the css can seem alive while the operation is being
     381                 :            :  * delayed.  If the delay affects user visible semantics, this test can be
     382                 :            :  * used to resolve the situation.
     383                 :            :  */
     384                 :            : static inline bool css_is_dying(struct cgroup_subsys_state *css)
     385                 :            : {
     386                 :          0 :         return !(css->flags & CSS_NO_REF) && percpu_ref_is_dying(&css->refcnt);
     387                 :            : }
     388                 :            : 
     389                 :            : /**
     390                 :            :  * css_put - put a css reference
     391                 :            :  * @css: target css
     392                 :            :  *
     393                 :            :  * Put a reference obtained via css_get() and css_tryget_online().
     394                 :            :  */
     395                 :          0 : static inline void css_put(struct cgroup_subsys_state *css)
     396                 :            : {
     397                 :          3 :         if (!(css->flags & CSS_NO_REF))
     398                 :          3 :                 percpu_ref_put(&css->refcnt);
     399                 :          0 : }
     400                 :            : 
     401                 :            : /**
     402                 :            :  * css_put_many - put css references
     403                 :            :  * @css: target css
     404                 :            :  * @n: number of references to put
     405                 :            :  *
     406                 :            :  * Put references obtained via css_get() and css_tryget_online().
     407                 :            :  */
     408                 :          0 : static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
     409                 :            : {
     410                 :          0 :         if (!(css->flags & CSS_NO_REF))
     411                 :          0 :                 percpu_ref_put_many(&css->refcnt, n);
     412                 :          0 : }
     413                 :            : 
     414                 :            : static inline void cgroup_get(struct cgroup *cgrp)
     415                 :            : {
     416                 :            :         css_get(&cgrp->self);
     417                 :            : }
     418                 :            : 
     419                 :            : static inline bool cgroup_tryget(struct cgroup *cgrp)
     420                 :            : {
     421                 :            :         return css_tryget(&cgrp->self);
     422                 :            : }
     423                 :            : 
     424                 :            : static inline void cgroup_put(struct cgroup *cgrp)
     425                 :            : {
     426                 :            :         css_put(&cgrp->self);
     427                 :            : }
     428                 :            : 
     429                 :            : /**
     430                 :            :  * task_css_set_check - obtain a task's css_set with extra access conditions
     431                 :            :  * @task: the task to obtain css_set for
     432                 :            :  * @__c: extra condition expression to be passed to rcu_dereference_check()
     433                 :            :  *
     434                 :            :  * A task's css_set is RCU protected, initialized and exited while holding
     435                 :            :  * task_lock(), and can only be modified while holding both cgroup_mutex
     436                 :            :  * and task_lock() while the task is alive.  This macro verifies that the
     437                 :            :  * caller is inside proper critical section and returns @task's css_set.
     438                 :            :  *
     439                 :            :  * The caller can also specify additional allowed conditions via @__c, such
     440                 :            :  * as locks used during the cgroup_subsys::attach() methods.
     441                 :            :  */
     442                 :            : #ifdef CONFIG_PROVE_RCU
     443                 :            : extern struct mutex cgroup_mutex;
     444                 :            : extern spinlock_t css_set_lock;
     445                 :            : #define task_css_set_check(task, __c)                                   \
     446                 :            :         rcu_dereference_check((task)->cgroups,                               \
     447                 :            :                 lockdep_is_held(&cgroup_mutex) ||                   \
     448                 :            :                 lockdep_is_held(&css_set_lock) ||                   \
     449                 :            :                 ((task)->flags & PF_EXITING) || (__c))
     450                 :            : #else
     451                 :            : #define task_css_set_check(task, __c)                                   \
     452                 :            :         rcu_dereference((task)->cgroups)
     453                 :            : #endif
     454                 :            : 
     455                 :            : /**
     456                 :            :  * task_css_check - obtain css for (task, subsys) w/ extra access conds
     457                 :            :  * @task: the target task
     458                 :            :  * @subsys_id: the target subsystem ID
     459                 :            :  * @__c: extra condition expression to be passed to rcu_dereference_check()
     460                 :            :  *
     461                 :            :  * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
     462                 :            :  * synchronization rules are the same as task_css_set_check().
     463                 :            :  */
     464                 :            : #define task_css_check(task, subsys_id, __c)                            \
     465                 :            :         task_css_set_check((task), (__c))->subsys[(subsys_id)]
     466                 :            : 
     467                 :            : /**
     468                 :            :  * task_css_set - obtain a task's css_set
     469                 :            :  * @task: the task to obtain css_set for
     470                 :            :  *
     471                 :            :  * See task_css_set_check().
     472                 :            :  */
     473                 :            : static inline struct css_set *task_css_set(struct task_struct *task)
     474                 :            : {
     475                 :          3 :         return task_css_set_check(task, false);
     476                 :            : }
     477                 :            : 
     478                 :            : /**
     479                 :            :  * task_css - obtain css for (task, subsys)
     480                 :            :  * @task: the target task
     481                 :            :  * @subsys_id: the target subsystem ID
     482                 :            :  *
     483                 :            :  * See task_css_check().
     484                 :            :  */
     485                 :            : static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
     486                 :            :                                                    int subsys_id)
     487                 :            : {
     488                 :          3 :         return task_css_check(task, subsys_id, false);
     489                 :            : }
     490                 :            : 
     491                 :            : /**
     492                 :            :  * task_get_css - find and get the css for (task, subsys)
     493                 :            :  * @task: the target task
     494                 :            :  * @subsys_id: the target subsystem ID
     495                 :            :  *
     496                 :            :  * Find the css for the (@task, @subsys_id) combination, increment a
     497                 :            :  * reference on and return it.  This function is guaranteed to return a
     498                 :            :  * valid css.  The returned css may already have been offlined.
     499                 :            :  */
     500                 :            : static inline struct cgroup_subsys_state *
     501                 :          1 : task_get_css(struct task_struct *task, int subsys_id)
     502                 :            : {
     503                 :            :         struct cgroup_subsys_state *css;
     504                 :            : 
     505                 :            :         rcu_read_lock();
     506                 :            :         while (true) {
     507                 :            :                 css = task_css(task, subsys_id);
     508                 :            :                 /*
     509                 :            :                  * Can't use css_tryget_online() here.  A task which has
     510                 :            :                  * PF_EXITING set may stay associated with an offline css.
     511                 :            :                  * If such task calls this function, css_tryget_online()
     512                 :            :                  * will keep failing.
     513                 :            :                  */
     514                 :          1 :                 if (likely(css_tryget(css)))
     515                 :            :                         break;
     516                 :          0 :                 cpu_relax();
     517                 :          0 :         }
     518                 :            :         rcu_read_unlock();
     519                 :          1 :         return css;
     520                 :            : }
     521                 :            : 
     522                 :            : /**
     523                 :            :  * task_css_is_root - test whether a task belongs to the root css
     524                 :            :  * @task: the target task
     525                 :            :  * @subsys_id: the target subsystem ID
     526                 :            :  *
     527                 :            :  * Test whether @task belongs to the root css on the specified subsystem.
     528                 :            :  * May be invoked in any context.
     529                 :            :  */
     530                 :            : static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
     531                 :            : {
     532                 :          3 :         return task_css_check(task, subsys_id, true) ==
     533                 :          3 :                 init_css_set.subsys[subsys_id];
     534                 :            : }
     535                 :            : 
     536                 :            : static inline struct cgroup *task_cgroup(struct task_struct *task,
     537                 :            :                                          int subsys_id)
     538                 :            : {
     539                 :          0 :         return task_css(task, subsys_id)->cgroup;
     540                 :            : }
     541                 :            : 
     542                 :          0 : static inline struct cgroup *task_dfl_cgroup(struct task_struct *task)
     543                 :            : {
     544                 :          3 :         return task_css_set(task)->dfl_cgrp;
     545                 :            : }
     546                 :            : 
     547                 :            : static inline struct cgroup *cgroup_parent(struct cgroup *cgrp)
     548                 :            : {
     549                 :          3 :         struct cgroup_subsys_state *parent_css = cgrp->self.parent;
     550                 :            : 
     551                 :          3 :         if (parent_css)
     552                 :            :                 return container_of(parent_css, struct cgroup, self);
     553                 :            :         return NULL;
     554                 :            : }
     555                 :            : 
     556                 :            : /**
     557                 :            :  * cgroup_is_descendant - test ancestry
     558                 :            :  * @cgrp: the cgroup to be tested
     559                 :            :  * @ancestor: possible ancestor of @cgrp
     560                 :            :  *
     561                 :            :  * Test whether @cgrp is a descendant of @ancestor.  It also returns %true
     562                 :            :  * if @cgrp == @ancestor.  This function is safe to call as long as @cgrp
     563                 :            :  * and @ancestor are accessible.
     564                 :            :  */
     565                 :            : static inline bool cgroup_is_descendant(struct cgroup *cgrp,
     566                 :            :                                         struct cgroup *ancestor)
     567                 :            : {
     568                 :          3 :         if (cgrp->root != ancestor->root || cgrp->level < ancestor->level)
     569                 :            :                 return false;
     570                 :          3 :         return cgrp->ancestor_ids[ancestor->level] == ancestor->id;
     571                 :            : }
     572                 :            : 
     573                 :            : /**
     574                 :            :  * cgroup_ancestor - find ancestor of cgroup
     575                 :            :  * @cgrp: cgroup to find ancestor of
     576                 :            :  * @ancestor_level: level of ancestor to find starting from root
     577                 :            :  *
     578                 :            :  * Find ancestor of cgroup at specified level starting from root if it exists
     579                 :            :  * and return pointer to it. Return NULL if @cgrp doesn't have ancestor at
     580                 :            :  * @ancestor_level.
     581                 :            :  *
     582                 :            :  * This function is safe to call as long as @cgrp is accessible.
     583                 :            :  */
     584                 :          0 : static inline struct cgroup *cgroup_ancestor(struct cgroup *cgrp,
     585                 :            :                                              int ancestor_level)
     586                 :            : {
     587                 :          0 :         if (cgrp->level < ancestor_level)
     588                 :            :                 return NULL;
     589                 :          0 :         while (cgrp && cgrp->level > ancestor_level)
     590                 :            :                 cgrp = cgroup_parent(cgrp);
     591                 :          0 :         return cgrp;
     592                 :            : }
     593                 :            : 
     594                 :            : /**
     595                 :            :  * task_under_cgroup_hierarchy - test task's membership of cgroup ancestry
     596                 :            :  * @task: the task to be tested
     597                 :            :  * @ancestor: possible ancestor of @task's cgroup
     598                 :            :  *
     599                 :            :  * Tests whether @task's default cgroup hierarchy is a descendant of @ancestor.
     600                 :            :  * It follows all the same rules as cgroup_is_descendant, and only applies
     601                 :            :  * to the default hierarchy.
     602                 :            :  */
     603                 :          0 : static inline bool task_under_cgroup_hierarchy(struct task_struct *task,
     604                 :            :                                                struct cgroup *ancestor)
     605                 :            : {
     606                 :            :         struct css_set *cset = task_css_set(task);
     607                 :            : 
     608                 :          0 :         return cgroup_is_descendant(cset->dfl_cgrp, ancestor);
     609                 :            : }
     610                 :            : 
     611                 :            : /* no synchronization, the result can only be used as a hint */
     612                 :            : static inline bool cgroup_is_populated(struct cgroup *cgrp)
     613                 :            : {
     614                 :          3 :         return cgrp->nr_populated_csets + cgrp->nr_populated_domain_children +
     615                 :          3 :                 cgrp->nr_populated_threaded_children;
     616                 :            : }
     617                 :            : 
     618                 :            : /* returns ino associated with a cgroup */
     619                 :            : static inline ino_t cgroup_ino(struct cgroup *cgrp)
     620                 :            : {
     621                 :          0 :         return cgrp->kn->id.ino;
     622                 :            : }
     623                 :            : 
     624                 :            : /* cft/css accessors for cftype->write() operation */
     625                 :            : static inline struct cftype *of_cft(struct kernfs_open_file *of)
     626                 :            : {
     627                 :          3 :         return of->kn->priv;
     628                 :            : }
     629                 :            : 
     630                 :            : struct cgroup_subsys_state *of_css(struct kernfs_open_file *of);
     631                 :            : 
     632                 :            : /* cft/css accessors for cftype->seq_*() operations */
     633                 :            : static inline struct cftype *seq_cft(struct seq_file *seq)
     634                 :            : {
     635                 :          3 :         return of_cft(seq->private);
     636                 :            : }
     637                 :            : 
     638                 :            : static inline struct cgroup_subsys_state *seq_css(struct seq_file *seq)
     639                 :            : {
     640                 :          3 :         return of_css(seq->private);
     641                 :            : }
     642                 :            : 
     643                 :            : /*
     644                 :            :  * Name / path handling functions.  All are thin wrappers around the kernfs
     645                 :            :  * counterparts and can be called under any context.
     646                 :            :  */
     647                 :            : 
     648                 :            : static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
     649                 :            : {
     650                 :          0 :         return kernfs_name(cgrp->kn, buf, buflen);
     651                 :            : }
     652                 :            : 
     653                 :            : static inline int cgroup_path(struct cgroup *cgrp, char *buf, size_t buflen)
     654                 :            : {
     655                 :          0 :         return kernfs_path(cgrp->kn, buf, buflen);
     656                 :            : }
     657                 :            : 
     658                 :            : static inline void pr_cont_cgroup_name(struct cgroup *cgrp)
     659                 :            : {
     660                 :          0 :         pr_cont_kernfs_name(cgrp->kn);
     661                 :            : }
     662                 :            : 
     663                 :            : static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
     664                 :            : {
     665                 :          0 :         pr_cont_kernfs_path(cgrp->kn);
     666                 :            : }
     667                 :            : 
     668                 :            : static inline struct psi_group *cgroup_psi(struct cgroup *cgrp)
     669                 :            : {
     670                 :            :         return &cgrp->psi;
     671                 :            : }
     672                 :            : 
     673                 :            : static inline void cgroup_init_kthreadd(void)
     674                 :            : {
     675                 :            :         /*
     676                 :            :          * kthreadd is inherited by all kthreads, keep it in the root so
     677                 :            :          * that the new kthreads are guaranteed to stay in the root until
     678                 :            :          * initialization is finished.
     679                 :            :          */
     680                 :          3 :         current->no_cgroup_migration = 1;
     681                 :            : }
     682                 :            : 
     683                 :            : static inline void cgroup_kthread_ready(void)
     684                 :            : {
     685                 :            :         /*
     686                 :            :          * This kthread finished initialization.  The creator should have
     687                 :            :          * set PF_NO_SETAFFINITY if this kthread should stay in the root.
     688                 :            :          */
     689                 :          3 :         current->no_cgroup_migration = 0;
     690                 :            : }
     691                 :            : 
     692                 :            : static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp)
     693                 :            : {
     694                 :          0 :         return &cgrp->kn->id;
     695                 :            : }
     696                 :            : 
     697                 :            : void cgroup_path_from_kernfs_id(const union kernfs_node_id *id,
     698                 :            :                                         char *buf, size_t buflen);
     699                 :            : #else /* !CONFIG_CGROUPS */
     700                 :            : 
     701                 :            : struct cgroup_subsys_state;
     702                 :            : struct cgroup;
     703                 :            : 
     704                 :            : static inline void css_get(struct cgroup_subsys_state *css) {}
     705                 :            : static inline void css_put(struct cgroup_subsys_state *css) {}
     706                 :            : static inline int cgroup_attach_task_all(struct task_struct *from,
     707                 :            :                                          struct task_struct *t) { return 0; }
     708                 :            : static inline int cgroupstats_build(struct cgroupstats *stats,
     709                 :            :                                     struct dentry *dentry) { return -EINVAL; }
     710                 :            : 
     711                 :            : static inline void cgroup_fork(struct task_struct *p) {}
     712                 :            : static inline int cgroup_can_fork(struct task_struct *p) { return 0; }
     713                 :            : static inline void cgroup_cancel_fork(struct task_struct *p) {}
     714                 :            : static inline void cgroup_post_fork(struct task_struct *p) {}
     715                 :            : static inline void cgroup_exit(struct task_struct *p) {}
     716                 :            : static inline void cgroup_release(struct task_struct *p) {}
     717                 :            : static inline void cgroup_free(struct task_struct *p) {}
     718                 :            : 
     719                 :            : static inline int cgroup_init_early(void) { return 0; }
     720                 :            : static inline int cgroup_init(void) { return 0; }
     721                 :            : static inline void cgroup_init_kthreadd(void) {}
     722                 :            : static inline void cgroup_kthread_ready(void) {}
     723                 :            : static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp)
     724                 :            : {
     725                 :            :         return NULL;
     726                 :            : }
     727                 :            : 
     728                 :            : static inline struct cgroup *cgroup_parent(struct cgroup *cgrp)
     729                 :            : {
     730                 :            :         return NULL;
     731                 :            : }
     732                 :            : 
     733                 :            : static inline struct psi_group *cgroup_psi(struct cgroup *cgrp)
     734                 :            : {
     735                 :            :         return NULL;
     736                 :            : }
     737                 :            : 
     738                 :            : static inline bool task_under_cgroup_hierarchy(struct task_struct *task,
     739                 :            :                                                struct cgroup *ancestor)
     740                 :            : {
     741                 :            :         return true;
     742                 :            : }
     743                 :            : 
     744                 :            : static inline void cgroup_path_from_kernfs_id(const union kernfs_node_id *id,
     745                 :            :         char *buf, size_t buflen) {}
     746                 :            : #endif /* !CONFIG_CGROUPS */
     747                 :            : 
     748                 :            : #ifdef CONFIG_CGROUPS
     749                 :            : /*
     750                 :            :  * cgroup scalable recursive statistics.
     751                 :            :  */
     752                 :            : void cgroup_rstat_updated(struct cgroup *cgrp, int cpu);
     753                 :            : void cgroup_rstat_flush(struct cgroup *cgrp);
     754                 :            : void cgroup_rstat_flush_irqsafe(struct cgroup *cgrp);
     755                 :            : void cgroup_rstat_flush_hold(struct cgroup *cgrp);
     756                 :            : void cgroup_rstat_flush_release(void);
     757                 :            : 
     758                 :            : /*
     759                 :            :  * Basic resource stats.
     760                 :            :  */
     761                 :            : #ifdef CONFIG_CGROUP_CPUACCT
     762                 :            : void cpuacct_charge(struct task_struct *tsk, u64 cputime);
     763                 :            : void cpuacct_account_field(struct task_struct *tsk, int index, u64 val);
     764                 :            : #else
     765                 :            : static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
     766                 :            : static inline void cpuacct_account_field(struct task_struct *tsk, int index,
     767                 :            :                                          u64 val) {}
     768                 :            : #endif
     769                 :            : 
     770                 :            : void __cgroup_account_cputime(struct cgroup *cgrp, u64 delta_exec);
     771                 :            : void __cgroup_account_cputime_field(struct cgroup *cgrp,
     772                 :            :                                     enum cpu_usage_stat index, u64 delta_exec);
     773                 :            : 
     774                 :          3 : static inline void cgroup_account_cputime(struct task_struct *task,
     775                 :            :                                           u64 delta_exec)
     776                 :            : {
     777                 :            :         struct cgroup *cgrp;
     778                 :            : 
     779                 :          3 :         cpuacct_charge(task, delta_exec);
     780                 :            : 
     781                 :            :         rcu_read_lock();
     782                 :            :         cgrp = task_dfl_cgroup(task);
     783                 :          3 :         if (cgroup_parent(cgrp))
     784                 :          3 :                 __cgroup_account_cputime(cgrp, delta_exec);
     785                 :            :         rcu_read_unlock();
     786                 :          3 : }
     787                 :            : 
     788                 :          3 : static inline void cgroup_account_cputime_field(struct task_struct *task,
     789                 :            :                                                 enum cpu_usage_stat index,
     790                 :            :                                                 u64 delta_exec)
     791                 :            : {
     792                 :            :         struct cgroup *cgrp;
     793                 :            : 
     794                 :          3 :         cpuacct_account_field(task, index, delta_exec);
     795                 :            : 
     796                 :            :         rcu_read_lock();
     797                 :            :         cgrp = task_dfl_cgroup(task);
     798                 :          3 :         if (cgroup_parent(cgrp))
     799                 :          3 :                 __cgroup_account_cputime_field(cgrp, index, delta_exec);
     800                 :            :         rcu_read_unlock();
     801                 :          3 : }
     802                 :            : 
     803                 :            : #else   /* CONFIG_CGROUPS */
     804                 :            : 
     805                 :            : static inline void cgroup_account_cputime(struct task_struct *task,
     806                 :            :                                           u64 delta_exec) {}
     807                 :            : static inline void cgroup_account_cputime_field(struct task_struct *task,
     808                 :            :                                                 enum cpu_usage_stat index,
     809                 :            :                                                 u64 delta_exec) {}
     810                 :            : 
     811                 :            : #endif  /* CONFIG_CGROUPS */
     812                 :            : 
     813                 :            : /*
     814                 :            :  * sock->sk_cgrp_data handling.  For more info, see sock_cgroup_data
     815                 :            :  * definition in cgroup-defs.h.
     816                 :            :  */
     817                 :            : #ifdef CONFIG_SOCK_CGROUP_DATA
     818                 :            : 
     819                 :            : #if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID)
     820                 :            : extern spinlock_t cgroup_sk_update_lock;
     821                 :            : #endif
     822                 :            : 
     823                 :            : void cgroup_sk_alloc_disable(void);
     824                 :            : void cgroup_sk_alloc(struct sock_cgroup_data *skcd);
     825                 :            : void cgroup_sk_clone(struct sock_cgroup_data *skcd);
     826                 :            : void cgroup_sk_free(struct sock_cgroup_data *skcd);
     827                 :            : 
     828                 :          0 : static inline struct cgroup *sock_cgroup_ptr(struct sock_cgroup_data *skcd)
     829                 :            : {
     830                 :            : #if defined(CONFIG_CGROUP_NET_PRIO) || defined(CONFIG_CGROUP_NET_CLASSID)
     831                 :            :         unsigned long v;
     832                 :            : 
     833                 :            :         /*
     834                 :            :          * @skcd->val is 64bit but the following is safe on 32bit too as we
     835                 :            :          * just need the lower ulong to be written and read atomically.
     836                 :            :          */
     837                 :          3 :         v = READ_ONCE(skcd->val);
     838                 :            : 
     839                 :          3 :         if (v & 3)
     840                 :            :                 return &cgrp_dfl_root.cgrp;
     841                 :            : 
     842                 :          3 :         return (struct cgroup *)(unsigned long)v ?: &cgrp_dfl_root.cgrp;
     843                 :            : #else
     844                 :            :         return (struct cgroup *)(unsigned long)skcd->val;
     845                 :            : #endif
     846                 :            : }
     847                 :            : 
     848                 :            : #else   /* CONFIG_CGROUP_DATA */
     849                 :            : 
     850                 :            : static inline void cgroup_sk_alloc(struct sock_cgroup_data *skcd) {}
     851                 :            : static inline void cgroup_sk_clone(struct sock_cgroup_data *skcd) {}
     852                 :            : static inline void cgroup_sk_free(struct sock_cgroup_data *skcd) {}
     853                 :            : 
     854                 :            : #endif  /* CONFIG_CGROUP_DATA */
     855                 :            : 
     856                 :            : struct cgroup_namespace {
     857                 :            :         refcount_t              count;
     858                 :            :         struct ns_common        ns;
     859                 :            :         struct user_namespace   *user_ns;
     860                 :            :         struct ucounts          *ucounts;
     861                 :            :         struct css_set          *root_cset;
     862                 :            : };
     863                 :            : 
     864                 :            : extern struct cgroup_namespace init_cgroup_ns;
     865                 :            : 
     866                 :            : #ifdef CONFIG_CGROUPS
     867                 :            : 
     868                 :            : void free_cgroup_ns(struct cgroup_namespace *ns);
     869                 :            : 
     870                 :            : struct cgroup_namespace *copy_cgroup_ns(unsigned long flags,
     871                 :            :                                         struct user_namespace *user_ns,
     872                 :            :                                         struct cgroup_namespace *old_ns);
     873                 :            : 
     874                 :            : int cgroup_path_ns(struct cgroup *cgrp, char *buf, size_t buflen,
     875                 :            :                    struct cgroup_namespace *ns);
     876                 :            : 
     877                 :            : #else /* !CONFIG_CGROUPS */
     878                 :            : 
     879                 :            : static inline void free_cgroup_ns(struct cgroup_namespace *ns) { }
     880                 :            : static inline struct cgroup_namespace *
     881                 :            : copy_cgroup_ns(unsigned long flags, struct user_namespace *user_ns,
     882                 :            :                struct cgroup_namespace *old_ns)
     883                 :            : {
     884                 :            :         return old_ns;
     885                 :            : }
     886                 :            : 
     887                 :            : #endif /* !CONFIG_CGROUPS */
     888                 :            : 
     889                 :            : static inline void get_cgroup_ns(struct cgroup_namespace *ns)
     890                 :            : {
     891                 :          3 :         if (ns)
     892                 :          3 :                 refcount_inc(&ns->count);
     893                 :            : }
     894                 :            : 
     895                 :          3 : static inline void put_cgroup_ns(struct cgroup_namespace *ns)
     896                 :            : {
     897                 :          3 :         if (ns && refcount_dec_and_test(&ns->count))
     898                 :          0 :                 free_cgroup_ns(ns);
     899                 :          3 : }
     900                 :            : 
     901                 :            : #ifdef CONFIG_CGROUPS
     902                 :            : 
     903                 :            : void cgroup_enter_frozen(void);
     904                 :            : void cgroup_leave_frozen(bool always_leave);
     905                 :            : void cgroup_update_frozen(struct cgroup *cgrp);
     906                 :            : void cgroup_freeze(struct cgroup *cgrp, bool freeze);
     907                 :            : void cgroup_freezer_migrate_task(struct task_struct *task, struct cgroup *src,
     908                 :            :                                  struct cgroup *dst);
     909                 :            : 
     910                 :          3 : static inline bool cgroup_task_freeze(struct task_struct *task)
     911                 :            : {
     912                 :            :         bool ret;
     913                 :            : 
     914                 :          3 :         if (task->flags & PF_KTHREAD)
     915                 :            :                 return false;
     916                 :            : 
     917                 :            :         rcu_read_lock();
     918                 :          3 :         ret = test_bit(CGRP_FREEZE, &task_dfl_cgroup(task)->flags);
     919                 :            :         rcu_read_unlock();
     920                 :            : 
     921                 :          3 :         return ret;
     922                 :            : }
     923                 :            : 
     924                 :            : static inline bool cgroup_task_frozen(struct task_struct *task)
     925                 :            : {
     926                 :          3 :         return task->frozen;
     927                 :            : }
     928                 :            : 
     929                 :            : #else /* !CONFIG_CGROUPS */
     930                 :            : 
     931                 :            : static inline void cgroup_enter_frozen(void) { }
     932                 :            : static inline void cgroup_leave_frozen(bool always_leave) { }
     933                 :            : static inline bool cgroup_task_freeze(struct task_struct *task)
     934                 :            : {
     935                 :            :         return false;
     936                 :            : }
     937                 :            : static inline bool cgroup_task_frozen(struct task_struct *task)
     938                 :            : {
     939                 :            :         return false;
     940                 :            : }
     941                 :            : 
     942                 :            : #endif /* !CONFIG_CGROUPS */
     943                 :            : 
     944                 :            : #ifdef CONFIG_CGROUP_BPF
     945                 :            : static inline void cgroup_bpf_get(struct cgroup *cgrp)
     946                 :            : {
     947                 :          3 :         percpu_ref_get(&cgrp->bpf.refcnt);
     948                 :            : }
     949                 :            : 
     950                 :            : static inline void cgroup_bpf_put(struct cgroup *cgrp)
     951                 :            : {
     952                 :          3 :         percpu_ref_put(&cgrp->bpf.refcnt);
     953                 :            : }
     954                 :            : 
     955                 :            : #else /* CONFIG_CGROUP_BPF */
     956                 :            : 
     957                 :            : static inline void cgroup_bpf_get(struct cgroup *cgrp) {}
     958                 :            : static inline void cgroup_bpf_put(struct cgroup *cgrp) {}
     959                 :            : 
     960                 :            : #endif /* CONFIG_CGROUP_BPF */
     961                 :            : 
     962                 :            : #endif /* _LINUX_CGROUP_H */
    

Generated by: LCOV version 1.14