LCOV - code coverage report
Current view: top level - kernel/cgroup - cgroup.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 1527 2440 62.6 %
Date: 2022-04-01 14:35:51 Functions: 109 176 61.9 %
Branches: 754 1695 44.5 %

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

Generated by: LCOV version 1.14