Merge branch 'for-3.15' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup

Pull cgroup updates from Tejun Heo:
 "A lot updates for cgroup:

   - The biggest one is cgroup's conversion to kernfs.  cgroup took
     after the long abandoned vfs-entangled sysfs implementation and
     made it even more convoluted over time.  cgroup's internal objects
     were fused with vfs objects which also brought in vfs locking and
     object lifetime rules.  Naturally, there are places where vfs rules
     don't fit and nasty hacks, such as credential switching or lock
     dance interleaving inode mutex and cgroup_mutex with object serial
     number comparison thrown in to decide whether the operation is
     actually necessary, needed to be employed.

     After conversion to kernfs, internal object lifetime and locking
     rules are mostly isolated from vfs interactions allowing shedding
     of several nasty hacks and overall simplification.  This will also
     allow implmentation of operations which may affect multiple cgroups
     which weren't possible before as it would have required nesting
     i_mutexes.

   - Various simplifications including dropping of module support,
     easier cgroup name/path handling, simplified cgroup file type
     handling and task_cg_lists optimization.

   - Prepatory changes for the planned unified hierarchy, which is still
     a patchset away from being actually operational.  The dummy
     hierarchy is updated to serve as the default unified hierarchy.
     Controllers which aren't claimed by other hierarchies are
     associated with it, which BTW was what the dummy hierarchy was for
     anyway.

   - Various fixes from Li and others.  This pull request includes some
     patches to add missing slab.h to various subsystems.  This was
     triggered xattr.h include removal from cgroup.h.  cgroup.h
     indirectly got included a lot of files which brought in xattr.h
     which brought in slab.h.

  There are several merge commits - one to pull in kernfs updates
  necessary for converting cgroup (already in upstream through
  driver-core), others for interfering changes in the fixes branch"

* 'for-3.15' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup: (74 commits)
  cgroup: remove useless argument from cgroup_exit()
  cgroup: fix spurious lockdep warning in cgroup_exit()
  cgroup: Use RCU_INIT_POINTER(x, NULL) in cgroup.c
  cgroup: break kernfs active_ref protection in cgroup directory operations
  cgroup: fix cgroup_taskset walking order
  cgroup: implement CFTYPE_ONLY_ON_DFL
  cgroup: make cgrp_dfl_root mountable
  cgroup: drop const from @buffer of cftype->write_string()
  cgroup: rename cgroup_dummy_root and related names
  cgroup: move ->subsys_mask from cgroupfs_root to cgroup
  cgroup: treat cgroup_dummy_root as an equivalent hierarchy during rebinding
  cgroup: remove NULL checks from [pr_cont_]cgroup_{name|path}()
  cgroup: use cgroup_setup_root() to initialize cgroup_dummy_root
  cgroup: reorganize cgroup bootstrapping
  cgroup: relocate setting of CGRP_DEAD
  cpuset: use rcu_read_lock() to protect task_cs()
  cgroup_freezer: document freezer_fork() subtleties
  cgroup: update cgroup_transfer_tasks() to either succeed or fail
  cgroup: drop task_lock() protection around task->cgroups
  cgroup: update how a newly forked task gets associated with css_set
  ...

4 files changed, 149 insertions, 160 deletions

diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 9450f025fe0c..c2515851c1aa 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -14,18 +14,17 @@
 #include <linux/rcupdate.h>
 #include <linux/rculist.h>
 #include <linux/cgroupstats.h>
-#include <linux/prio_heap.h>
 #include <linux/rwsem.h>
 #include <linux/idr.h>
 #include <linux/workqueue.h>
-#include <linux/xattr.h>
 #include <linux/fs.h>
 #include <linux/percpu-refcount.h>
 #include <linux/seq_file.h>
+#include <linux/kernfs.h>
 
 #ifdef CONFIG_CGROUPS
 
-struct cgroupfs_root;
+struct cgroup_root;
 struct cgroup_subsys;
 struct inode;
 struct cgroup;
@@ -34,31 +33,16 @@ extern int cgroup_init_early(void);
 extern int cgroup_init(void);
 extern void cgroup_fork(struct task_struct *p);
 extern void cgroup_post_fork(struct task_struct *p);
-extern void cgroup_exit(struct task_struct *p, int run_callbacks);
+extern void cgroup_exit(struct task_struct *p);
 extern int cgroupstats_build(struct cgroupstats *stats,
                                 struct dentry *dentry);
-extern int cgroup_load_subsys(struct cgroup_subsys *ss);
-extern void cgroup_unload_subsys(struct cgroup_subsys *ss);
 
 extern int proc_cgroup_show(struct seq_file *, void *);
 
-/*
- * Define the enumeration of all cgroup subsystems.
- *
- * We define ids for builtin subsystems and then modular ones.
- */
-#define SUBSYS(_x) _x ## _subsys_id,
+/* define the enumeration of all cgroup subsystems */
+#define SUBSYS(_x) _x ## _cgrp_id,
 enum cgroup_subsys_id {
-#define IS_SUBSYS_ENABLED(option) IS_BUILTIN(option)
-#include <linux/cgroup_subsys.h>
-#undef IS_SUBSYS_ENABLED
-        CGROUP_BUILTIN_SUBSYS_COUNT,
-
-        __CGROUP_SUBSYS_TEMP_PLACEHOLDER = CGROUP_BUILTIN_SUBSYS_COUNT - 1,
-
-#define IS_SUBSYS_ENABLED(option) IS_MODULE(option)
 #include <linux/cgroup_subsys.h>
-#undef IS_SUBSYS_ENABLED
         CGROUP_SUBSYS_COUNT,
 };
 #undef SUBSYS
@@ -153,11 +137,6 @@ enum {
         CGRP_SANE_BEHAVIOR,
 };
 
-struct cgroup_name {
-        struct rcu_head rcu_head;
-        char name[];
-};
-
 struct cgroup {
         unsigned long flags;            /* "unsigned long" so bitops work */
 
@@ -174,16 +153,17 @@ struct cgroup {
         /* the number of attached css's */
         int nr_css;
 
+        atomic_t refcnt;
+
         /*
          * We link our 'sibling' struct into our parent's 'children'.
          * Our children link their 'sibling' into our 'children'.
          */
         struct list_head sibling;       /* my parent's children */
         struct list_head children;      /* my children */
-        struct list_head files;         /* my files */
 
         struct cgroup *parent;          /* my parent */
-        struct dentry *dentry;          /* cgroup fs entry, RCU protected */
+        struct kernfs_node *kn;         /* cgroup kernfs entry */
 
         /*
          * Monotonically increasing unique serial number which defines a
@@ -193,23 +173,13 @@ struct cgroup {
          */
         u64 serial_nr;
 
-        /*
-         * This is a copy of dentry->d_name, and it's needed because
-         * we can't use dentry->d_name in cgroup_path().
-         *
-         * You must acquire rcu_read_lock() to access cgrp->name, and
-         * the only place that can change it is rename(), which is
-         * protected by parent dir's i_mutex.
-         *
-         * Normally you should use cgroup_name() wrapper rather than
-         * access it directly.
-         */
-        struct cgroup_name __rcu *name;
+        /* The bitmask of subsystems attached to this cgroup */
+        unsigned long subsys_mask;
 
         /* Private pointers for each registered subsystem */
         struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
 
-        struct cgroupfs_root *root;
+        struct cgroup_root *root;
 
         /*
          * List of cgrp_cset_links pointing at css_sets with tasks in this
@@ -237,14 +207,11 @@ struct cgroup {
         /* For css percpu_ref killing and RCU-protected deletion */
         struct rcu_head rcu_head;
         struct work_struct destroy_work;
-
-        /* directory xattrs */
-        struct simple_xattrs xattrs;
 };
 
 #define MAX_CGROUP_ROOT_NAMELEN 64
 
-/* cgroupfs_root->flags */
+/* cgroup_root->flags */
 enum {
         /*
          * Unfortunately, cgroup core and various controllers are riddled
@@ -262,8 +229,8 @@ enum {
          *
          * The followings are the behaviors currently affected this flag.
          *
-         * - Mount options "noprefix" and "clone_children" are disallowed.
-         *   Also, cgroupfs file cgroup.clone_children is not created.
+         * - Mount options "noprefix", "xattr", "clone_children",
+         *   "release_agent" and "name" are disallowed.
          *
          * - When mounting an existing superblock, mount options should
          *   match.
@@ -281,6 +248,11 @@ enum {
          * - "release_agent" and "notify_on_release" are removed.
          *   Replacement notification mechanism will be implemented.
          *
+         * - "cgroup.clone_children" is removed.
+         *
+         * - If mount is requested with sane_behavior but without any
+         *   subsystem, the default unified hierarchy is mounted.
+         *
          * - cpuset: tasks will be kept in empty cpusets when hotplug happens
          *   and take masks of ancestors with non-empty cpus/mems, instead of
          *   being moved to an ancestor.
@@ -300,29 +272,24 @@ enum {
 
         /* mount options live below bit 16 */
         CGRP_ROOT_OPTION_MASK   = (1 << 16) - 1,
-
-        CGRP_ROOT_SUBSYS_BOUND  = (1 << 16), /* subsystems finished binding */
 };
 
 /*
- * A cgroupfs_root represents the root of a cgroup hierarchy, and may be
- * associated with a superblock to form an active hierarchy.  This is
+ * A cgroup_root represents the root of a cgroup hierarchy, and may be
+ * associated with a kernfs_root to form an active hierarchy.  This is
  * internal to cgroup core.  Don't access directly from controllers.
  */
-struct cgroupfs_root {
-        struct super_block *sb;
-
-        /* The bitmask of subsystems attached to this hierarchy */
-        unsigned long subsys_mask;
+struct cgroup_root {
+        struct kernfs_root *kf_root;
 
         /* Unique id for this hierarchy. */
         int hierarchy_id;
 
-        /* The root cgroup for this hierarchy */
-        struct cgroup top_cgroup;
+        /* The root cgroup.  Root is destroyed on its release. */
+        struct cgroup cgrp;
 
-        /* Tracks how many cgroups are currently defined in hierarchy.*/
-        int number_of_cgroups;
+        /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
+        atomic_t nr_cgrps;
 
         /* A list running through the active hierarchies */
         struct list_head root_list;
@@ -360,10 +327,14 @@ struct css_set {
         struct hlist_node hlist;
 
         /*
-         * List running through all tasks using this cgroup
-         * group. Protected by css_set_lock
+         * Lists running through all tasks using this cgroup group.
+         * mg_tasks lists tasks which belong to this cset but are in the
+         * process of being migrated out or in.  Protected by
+         * css_set_rwsem, but, during migration, once tasks are moved to
+         * mg_tasks, it can be read safely while holding cgroup_mutex.
          */
         struct list_head tasks;
+        struct list_head mg_tasks;
 
         /*
          * List of cgrp_cset_links pointing at cgroups referenced from this
@@ -372,13 +343,29 @@ struct css_set {
         struct list_head cgrp_links;
 
         /*
-         * Set of subsystem states, one for each subsystem. This array
-         * is immutable after creation apart from the init_css_set
-         * during subsystem registration (at boot time) and modular subsystem
-         * loading/unloading.
+         * Set of subsystem states, one for each subsystem. This array is
+         * immutable after creation apart from the init_css_set during
+         * subsystem registration (at boot time).
          */
         struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
 
+        /*
+         * List of csets participating in the on-going migration either as
+         * source or destination.  Protected by cgroup_mutex.
+         */
+        struct list_head mg_preload_node;
+        struct list_head mg_node;
+
+        /*
+         * If this cset is acting as the source of migration the following
+         * two fields are set.  mg_src_cgrp is the source cgroup of the
+         * on-going migration and mg_dst_cset is the destination cset the
+         * target tasks on this cset should be migrated to.  Protected by
+         * cgroup_mutex.
+         */
+        struct cgroup *mg_src_cgrp;
+        struct css_set *mg_dst_cset;
+
         /* For RCU-protected deletion */
         struct rcu_head rcu_head;
 };
@@ -397,6 +384,7 @@ enum {
         CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cgrp */
         CFTYPE_INSANE           = (1 << 2),     /* don't create if sane_behavior */
         CFTYPE_NO_PREFIX        = (1 << 3),     /* (DON'T USE FOR NEW FILES) no subsys prefix */
+        CFTYPE_ONLY_ON_DFL      = (1 << 4),     /* only on default hierarchy */
 };
 
 #define MAX_CFTYPE_NAME         64
@@ -416,8 +404,9 @@ struct cftype {
         umode_t mode;
 
         /*
-         * If non-zero, defines the maximum length of string that can
-         * be passed to write_string; defaults to 64
+         * The maximum length of string, excluding trailing nul, that can
+         * be passed to write_string.  If < PAGE_SIZE-1, PAGE_SIZE-1 is
+         * assumed.
          */
         size_t max_write_len;
 
@@ -425,10 +414,12 @@ struct cftype {
         unsigned int flags;
 
         /*
-         * The subsys this file belongs to.  Initialized automatically
-         * during registration.  NULL for cgroup core files.
+         * Fields used for internal bookkeeping.  Initialized automatically
+         * during registration.
          */
-        struct cgroup_subsys *ss;
+        struct cgroup_subsys *ss;       /* NULL for cgroup core files */
+        struct list_head node;          /* anchored at ss->cfts */
+        struct kernfs_ops *kf_ops;
 
         /*
          * read_u64() is a shortcut for the common case of returning a
@@ -467,7 +458,7 @@ struct cftype {
          * Returns 0 or -ve error code.
          */
         int (*write_string)(struct cgroup_subsys_state *css, struct cftype *cft,
-                            const char *buffer);
+                            char *buffer);
         /*
          * trigger() callback can be used to get some kick from the
          * userspace, when the actual string written is not important
@@ -475,37 +466,18 @@ struct cftype {
          * kick type for multiplexing.
          */
         int (*trigger)(struct cgroup_subsys_state *css, unsigned int event);
-};
 
-/*
- * cftype_sets describe cftypes belonging to a subsystem and are chained at
- * cgroup_subsys->cftsets.  Each cftset points to an array of cftypes
- * terminated by zero length name.
- */
-struct cftype_set {
-        struct list_head                node;   /* chained at subsys->cftsets */
-        struct cftype                   *cfts;
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lock_class_key   lockdep_key;
+#endif
 };
 
-/*
- * cgroupfs file entry, pointed to from leaf dentry->d_fsdata.  Don't
- * access directly.
- */
-struct cfent {
-        struct list_head                node;
-        struct dentry                   *dentry;
-        struct cftype                   *type;
-        struct cgroup_subsys_state      *css;
-
-        /* file xattrs */
-        struct simple_xattrs            xattrs;
-};
+extern struct cgroup_root cgrp_dfl_root;
 
-/* seq_file->private points to the following, only ->priv is public */
-struct cgroup_open_file {
-        struct cfent                    *cfe;
-        void                            *priv;
-};
+static inline bool cgroup_on_dfl(const struct cgroup *cgrp)
+{
+        return cgrp->root == &cgrp_dfl_root;
+}
 
 /*
  * See the comment above CGRP_ROOT_SANE_BEHAVIOR for details.  This
@@ -516,34 +488,63 @@ static inline bool cgroup_sane_behavior(const struct cgroup *cgrp)
         return cgrp->root->flags & CGRP_ROOT_SANE_BEHAVIOR;
 }
 
-/* Caller should hold rcu_read_lock() */
-static inline const char *cgroup_name(const struct cgroup *cgrp)
+/* no synchronization, the result can only be used as a hint */
+static inline bool cgroup_has_tasks(struct cgroup *cgrp)
 {
-        return rcu_dereference(cgrp->name)->name;
+        return !list_empty(&cgrp->cset_links);
 }
 
-static inline struct cgroup_subsys_state *seq_css(struct seq_file *seq)
+/* returns ino associated with a cgroup, 0 indicates unmounted root */
+static inline ino_t cgroup_ino(struct cgroup *cgrp)
 {
-        struct cgroup_open_file *of = seq->private;
-        return of->cfe->css;
+        if (cgrp->kn)
+                return cgrp->kn->ino;
+        else
+                return 0;
 }
 
 static inline struct cftype *seq_cft(struct seq_file *seq)
 {
-        struct cgroup_open_file *of = seq->private;
-        return of->cfe->type;
+        struct kernfs_open_file *of = seq->private;
+
+        return of->kn->priv;
+}
+
+struct cgroup_subsys_state *seq_css(struct seq_file *seq);
+
+/*
+ * Name / path handling functions.  All are thin wrappers around the kernfs
+ * counterparts and can be called under any context.
+ */
+
+static inline int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
+{
+        return kernfs_name(cgrp->kn, buf, buflen);
 }
 
+static inline char * __must_check cgroup_path(struct cgroup *cgrp, char *buf,
+                                              size_t buflen)
+{
+        return kernfs_path(cgrp->kn, buf, buflen);
+}
+
+static inline void pr_cont_cgroup_name(struct cgroup *cgrp)
+{
+        pr_cont_kernfs_name(cgrp->kn);
+}
+
+static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
+{
+        pr_cont_kernfs_path(cgrp->kn);
+}
+
+char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
+
 int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
 int cgroup_rm_cftypes(struct cftype *cfts);
 
 bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
 
-int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
-int task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
-
-int cgroup_task_count(const struct cgroup *cgrp);
-
 /*
  * Control Group taskset, used to pass around set of tasks to cgroup_subsys
  * methods.
@@ -551,22 +552,15 @@ int cgroup_task_count(const struct cgroup *cgrp);
 struct cgroup_taskset;
 struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
 struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
-struct cgroup_subsys_state *cgroup_taskset_cur_css(struct cgroup_taskset *tset,
-                                                   int subsys_id);
-int cgroup_taskset_size(struct cgroup_taskset *tset);
 
 /**
  * cgroup_taskset_for_each - iterate cgroup_taskset
  * @task: the loop cursor
- * @skip_css: skip if task's css matches this, %NULL to iterate through all
  * @tset: taskset to iterate
  */
-#define cgroup_taskset_for_each(task, skip_css, tset)                   \
+#define cgroup_taskset_for_each(task, tset)                             \
         for ((task) = cgroup_taskset_first((tset)); (task);             \
-             (task) = cgroup_taskset_next((tset)))                      \
-                if (!(skip_css) ||                                      \
-                    cgroup_taskset_cur_css((tset),                      \
-                        (skip_css)->ss->subsys_id) != (skip_css))
+             (task) = cgroup_taskset_next((tset)))
 
 /*
  * Control Group subsystem type.
@@ -591,7 +585,6 @@ struct cgroup_subsys {
                      struct task_struct *task);
         void (*bind)(struct cgroup_subsys_state *root_css);
 
-        int subsys_id;
         int disabled;
         int early_init;
 
@@ -610,27 +603,26 @@ struct cgroup_subsys {
         bool broken_hierarchy;
         bool warned_broken_hierarchy;
 
+        /* the following two fields are initialized automtically during boot */
+        int id;
 #define MAX_CGROUP_TYPE_NAMELEN 32
         const char *name;
 
         /* link to parent, protected by cgroup_lock() */
-        struct cgroupfs_root *root;
+        struct cgroup_root *root;
 
-        /* list of cftype_sets */
-        struct list_head cftsets;
+        /*
+         * List of cftypes.  Each entry is the first entry of an array
+         * terminated by zero length name.
+         */
+        struct list_head cfts;
 
-        /* base cftypes, automatically [de]registered with subsys itself */
+        /* base cftypes, automatically registered with subsys itself */
         struct cftype *base_cftypes;
-        struct cftype_set base_cftset;
-
-        /* should be defined only by modular subsystems */
-        struct module *module;
 };
 
-#define SUBSYS(_x) extern struct cgroup_subsys _x ## _subsys;
-#define IS_SUBSYS_ENABLED(option) IS_BUILTIN(option)
+#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
 #include <linux/cgroup_subsys.h>
-#undef IS_SUBSYS_ENABLED
 #undef SUBSYS
 
 /**
@@ -661,10 +653,12 @@ struct cgroup_subsys_state *css_parent(struct cgroup_subsys_state *css)
  */
 #ifdef CONFIG_PROVE_RCU
 extern struct mutex cgroup_mutex;
+extern struct rw_semaphore css_set_rwsem;
 #define task_css_set_check(task, __c)                                   \
         rcu_dereference_check((task)->cgroups,                          \
-                lockdep_is_held(&(task)->alloc_lock) ||                 \
-                lockdep_is_held(&cgroup_mutex) || (__c))
+                lockdep_is_held(&cgroup_mutex) ||                       \
+                lockdep_is_held(&css_set_rwsem) ||                      \
+                ((task)->flags & PF_EXITING) || (__c))
 #else
 #define task_css_set_check(task, __c)                                   \
         rcu_dereference((task)->cgroups)
@@ -837,16 +831,11 @@ void css_task_iter_start(struct cgroup_subsys_state *css,
 struct task_struct *css_task_iter_next(struct css_task_iter *it);
 void css_task_iter_end(struct css_task_iter *it);
 
-int css_scan_tasks(struct cgroup_subsys_state *css,
-                   bool (*test)(struct task_struct *, void *),
-                   void (*process)(struct task_struct *, void *),
-                   void *data, struct ptr_heap *heap);
-
 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
 int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
 
-struct cgroup_subsys_state *css_from_dir(struct dentry *dentry,
-                                         struct cgroup_subsys *ss);
+struct cgroup_subsys_state *css_tryget_from_dir(struct dentry *dentry,
+                                                struct cgroup_subsys *ss);
 
 #else /* !CONFIG_CGROUPS */
 
@@ -854,7 +843,7 @@ static inline int cgroup_init_early(void) { return 0; }
 static inline int cgroup_init(void) { return 0; }
 static inline void cgroup_fork(struct task_struct *p) {}
 static inline void cgroup_post_fork(struct task_struct *p) {}
-static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
+static inline void cgroup_exit(struct task_struct *p) {}
 
 static inline int cgroupstats_build(struct cgroupstats *stats,
                                         struct dentry *dentry)
diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h
index 7b99d717411d..768fe44e19f0 100644
--- a/include/linux/cgroup_subsys.h
+++ b/include/linux/cgroup_subsys.h
@@ -3,51 +3,51 @@
  *
  * DO NOT ADD ANY SUBSYSTEM WITHOUT EXPLICIT ACKS FROM CGROUP MAINTAINERS.
  */
-#if IS_SUBSYS_ENABLED(CONFIG_CPUSETS)
+#if IS_ENABLED(CONFIG_CPUSETS)
 SUBSYS(cpuset)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_DEBUG)
+#if IS_ENABLED(CONFIG_CGROUP_DEBUG)
 SUBSYS(debug)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_SCHED)
-SUBSYS(cpu_cgroup)
+#if IS_ENABLED(CONFIG_CGROUP_SCHED)
+SUBSYS(cpu)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_CPUACCT)
+#if IS_ENABLED(CONFIG_CGROUP_CPUACCT)
 SUBSYS(cpuacct)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_MEMCG)
-SUBSYS(mem_cgroup)
+#if IS_ENABLED(CONFIG_MEMCG)
+SUBSYS(memory)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_DEVICE)
+#if IS_ENABLED(CONFIG_CGROUP_DEVICE)
 SUBSYS(devices)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_FREEZER)
+#if IS_ENABLED(CONFIG_CGROUP_FREEZER)
 SUBSYS(freezer)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_NET_CLASSID)
+#if IS_ENABLED(CONFIG_CGROUP_NET_CLASSID)
 SUBSYS(net_cls)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_BLK_CGROUP)
+#if IS_ENABLED(CONFIG_BLK_CGROUP)
 SUBSYS(blkio)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_PERF)
-SUBSYS(perf)
+#if IS_ENABLED(CONFIG_CGROUP_PERF)
+SUBSYS(perf_event)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_NET_PRIO)
+#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
 SUBSYS(net_prio)
 #endif
 
-#if IS_SUBSYS_ENABLED(CONFIG_CGROUP_HUGETLB)
+#if IS_ENABLED(CONFIG_CGROUP_HUGETLB)
 SUBSYS(hugetlb)
 #endif
 /*
diff --git a/include/linux/hugetlb_cgroup.h b/include/linux/hugetlb_cgroup.h
index 787bba3bf552..0129f89cf98d 100644
--- a/include/linux/hugetlb_cgroup.h
+++ b/include/linux/hugetlb_cgroup.h
@@ -49,7 +49,7 @@ int set_hugetlb_cgroup(struct page *page, struct hugetlb_cgroup *h_cg)
 
 static inline bool hugetlb_cgroup_disabled(void)
 {
-        if (hugetlb_subsys.disabled)
+        if (hugetlb_cgrp_subsys.disabled)
                 return true;
         return false;
 }
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index abd0113b6620..eccfb4a4b379 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -162,7 +162,7 @@ extern int do_swap_account;
 
 static inline bool mem_cgroup_disabled(void)
 {
-        if (mem_cgroup_subsys.disabled)
+        if (memory_cgrp_subsys.disabled)
                 return true;
         return false;
 }