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

Pull cgroup updates from Tejun Heo:
 "A lot of activities on the cgroup front.  Most changes aren't visible
  to userland at all at this point and are laying foundation for the
  planned unified hierarchy.

   - The biggest change is decoupling the lifetime management of css
     (cgroup_subsys_state) from that of cgroup's.  Because controllers
     (cpu, memory, block and so on) will need to be dynamically enabled
     and disabled, css which is the association point between a cgroup
     and a controller may come and go dynamically across the lifetime of
     a cgroup.  Till now, css's were created when the associated cgroup
     was created and stayed till the cgroup got destroyed.

     Assumptions around this tight coupling permeated through cgroup
     core and controllers.  These assumptions are gradually removed,
     which consists bulk of patches, and css destruction path is
     completely decoupled from cgroup destruction path.  Note that
     decoupling of creation path is relatively easy on top of these
     changes and the patchset is pending for the next window.

   - cgroup has its own event mechanism cgroup.event_control, which is
     only used by memcg.  It is overly complex trying to achieve high
     flexibility whose benefits seem dubious at best.  Going forward,
     new events will simply generate file modified event and the
     existing mechanism is being made specific to memcg.  This pull
     request contains prepatory patches for such change.

   - Various fixes and cleanups"

Fixed up conflict in kernel/cgroup.c as per Tejun.

* 'for-3.12' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/cgroup: (69 commits)
  cgroup: fix cgroup_css() invocation in css_from_id()
  cgroup: make cgroup_write_event_control() use css_from_dir() instead of __d_cgrp()
  cgroup: make cgroup_event hold onto cgroup_subsys_state instead of cgroup
  cgroup: implement CFTYPE_NO_PREFIX
  cgroup: make cgroup_css() take cgroup_subsys * instead and allow NULL subsys
  cgroup: rename cgroup_css_from_dir() to css_from_dir() and update its syntax
  cgroup: fix cgroup_write_event_control()
  cgroup: fix subsystem file accesses on the root cgroup
  cgroup: change cgroup_from_id() to css_from_id()
  cgroup: use css_get() in cgroup_create() to check CSS_ROOT
  cpuset: remove an unncessary forward declaration
  cgroup: RCU protect each cgroup_subsys_state release
  cgroup: move subsys file removal to kill_css()
  cgroup: factor out kill_css()
  cgroup: decouple cgroup_subsys_state destruction from cgroup destruction
  cgroup: replace cgroup->css_kill_cnt with ->nr_css
  cgroup: bounce cgroup_subsys_state ref kill confirmation to a work item
  cgroup: move cgroup->subsys[] assignment to online_css()
  cgroup: reorganize css init / exit paths
  cgroup: add __rcu modifier to cgroup->subsys[]
  ...

3 files changed, 137 insertions, 180 deletions

diff --git a/mm/hugetlb_cgroup.c b/mm/hugetlb_cgroup.c
index 9cea7de22ffb..bda8e44f6fde 100644
--- a/mm/hugetlb_cgroup.c
+++ b/mm/hugetlb_cgroup.c
@@ -36,21 +36,13 @@ static struct hugetlb_cgroup *root_h_cgroup __read_mostly;
 static inline
 struct hugetlb_cgroup *hugetlb_cgroup_from_css(struct cgroup_subsys_state *s)
 {
-        return container_of(s, struct hugetlb_cgroup, css);
-}
-
-static inline
-struct hugetlb_cgroup *hugetlb_cgroup_from_cgroup(struct cgroup *cgroup)
-{
-        return hugetlb_cgroup_from_css(cgroup_subsys_state(cgroup,
-                                                           hugetlb_subsys_id));
+        return s ? container_of(s, struct hugetlb_cgroup, css) : NULL;
 }
 
 static inline
 struct hugetlb_cgroup *hugetlb_cgroup_from_task(struct task_struct *task)
 {
-        return hugetlb_cgroup_from_css(task_subsys_state(task,
-                                                         hugetlb_subsys_id));
+        return hugetlb_cgroup_from_css(task_css(task, hugetlb_subsys_id));
 }
 
 static inline bool hugetlb_cgroup_is_root(struct hugetlb_cgroup *h_cg)
@@ -58,17 +50,15 @@ static inline bool hugetlb_cgroup_is_root(struct hugetlb_cgroup *h_cg)
         return (h_cg == root_h_cgroup);
 }
 
-static inline struct hugetlb_cgroup *parent_hugetlb_cgroup(struct cgroup *cg)
+static inline struct hugetlb_cgroup *
+parent_hugetlb_cgroup(struct hugetlb_cgroup *h_cg)
 {
-        if (!cg->parent)
-                return NULL;
-        return hugetlb_cgroup_from_cgroup(cg->parent);
+        return hugetlb_cgroup_from_css(css_parent(&h_cg->css));
 }
 
-static inline bool hugetlb_cgroup_have_usage(struct cgroup *cg)
+static inline bool hugetlb_cgroup_have_usage(struct hugetlb_cgroup *h_cg)
 {
         int idx;
-        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_cgroup(cg);
 
         for (idx = 0; idx < hugetlb_max_hstate; idx++) {
                 if ((res_counter_read_u64(&h_cg->hugepage[idx], RES_USAGE)) > 0)
@@ -77,19 +67,18 @@ static inline bool hugetlb_cgroup_have_usage(struct cgroup *cg)
         return false;
 }
 
-static struct cgroup_subsys_state *hugetlb_cgroup_css_alloc(struct cgroup *cgroup)
+static struct cgroup_subsys_state *
+hugetlb_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
 {
+        struct hugetlb_cgroup *parent_h_cgroup = hugetlb_cgroup_from_css(parent_css);
+        struct hugetlb_cgroup *h_cgroup;
         int idx;
-        struct cgroup *parent_cgroup;
-        struct hugetlb_cgroup *h_cgroup, *parent_h_cgroup;
 
         h_cgroup = kzalloc(sizeof(*h_cgroup), GFP_KERNEL);
         if (!h_cgroup)
                 return ERR_PTR(-ENOMEM);
 
-        parent_cgroup = cgroup->parent;
-        if (parent_cgroup) {
-                parent_h_cgroup = hugetlb_cgroup_from_cgroup(parent_cgroup);
+        if (parent_h_cgroup) {
                 for (idx = 0; idx < HUGE_MAX_HSTATE; idx++)
                         res_counter_init(&h_cgroup->hugepage[idx],
                                          &parent_h_cgroup->hugepage[idx]);
@@ -101,11 +90,11 @@ static struct cgroup_subsys_state *hugetlb_cgroup_css_alloc(struct cgroup *cgrou
         return &h_cgroup->css;
 }
 
-static void hugetlb_cgroup_css_free(struct cgroup *cgroup)
+static void hugetlb_cgroup_css_free(struct cgroup_subsys_state *css)
 {
         struct hugetlb_cgroup *h_cgroup;
 
-        h_cgroup = hugetlb_cgroup_from_cgroup(cgroup);
+        h_cgroup = hugetlb_cgroup_from_css(css);
         kfree(h_cgroup);
 }
 
@@ -117,15 +106,14 @@ static void hugetlb_cgroup_css_free(struct cgroup *cgroup)
  * page reference and test for page active here. This function
  * cannot fail.
  */
-static void hugetlb_cgroup_move_parent(int idx, struct cgroup *cgroup,
+static void hugetlb_cgroup_move_parent(int idx, struct hugetlb_cgroup *h_cg,
                                        struct page *page)
 {
         int csize;
         struct res_counter *counter;
         struct res_counter *fail_res;
         struct hugetlb_cgroup *page_hcg;
-        struct hugetlb_cgroup *h_cg   = hugetlb_cgroup_from_cgroup(cgroup);
-        struct hugetlb_cgroup *parent = parent_hugetlb_cgroup(cgroup);
+        struct hugetlb_cgroup *parent = parent_hugetlb_cgroup(h_cg);
 
         page_hcg = hugetlb_cgroup_from_page(page);
         /*
@@ -155,8 +143,9 @@ out:
  * Force the hugetlb cgroup to empty the hugetlb resources by moving them to
  * the parent cgroup.
  */
-static void hugetlb_cgroup_css_offline(struct cgroup *cgroup)
+static void hugetlb_cgroup_css_offline(struct cgroup_subsys_state *css)
 {
+        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_css(css);
         struct hstate *h;
         struct page *page;
         int idx = 0;
@@ -165,13 +154,13 @@ static void hugetlb_cgroup_css_offline(struct cgroup *cgroup)
                 for_each_hstate(h) {
                         spin_lock(&hugetlb_lock);
                         list_for_each_entry(page, &h->hugepage_activelist, lru)
-                                hugetlb_cgroup_move_parent(idx, cgroup, page);
+                                hugetlb_cgroup_move_parent(idx, h_cg, page);
 
                         spin_unlock(&hugetlb_lock);
                         idx++;
                 }
                 cond_resched();
-        } while (hugetlb_cgroup_have_usage(cgroup));
+        } while (hugetlb_cgroup_have_usage(h_cg));
 }
 
 int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
@@ -253,14 +242,15 @@ void hugetlb_cgroup_uncharge_cgroup(int idx, unsigned long nr_pages,
         return;
 }
 
-static ssize_t hugetlb_cgroup_read(struct cgroup *cgroup, struct cftype *cft,
-                                   struct file *file, char __user *buf,
-                                   size_t nbytes, loff_t *ppos)
+static ssize_t hugetlb_cgroup_read(struct cgroup_subsys_state *css,
+                                   struct cftype *cft, struct file *file,
+                                   char __user *buf, size_t nbytes,
+                                   loff_t *ppos)
 {
         u64 val;
         char str[64];
         int idx, name, len;
-        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_cgroup(cgroup);
+        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_css(css);
 
         idx = MEMFILE_IDX(cft->private);
         name = MEMFILE_ATTR(cft->private);
@@ -270,12 +260,12 @@ static ssize_t hugetlb_cgroup_read(struct cgroup *cgroup, struct cftype *cft,
         return simple_read_from_buffer(buf, nbytes, ppos, str, len);
 }
 
-static int hugetlb_cgroup_write(struct cgroup *cgroup, struct cftype *cft,
-                                const char *buffer)
+static int hugetlb_cgroup_write(struct cgroup_subsys_state *css,
+                                struct cftype *cft, const char *buffer)
 {
         int idx, name, ret;
         unsigned long long val;
-        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_cgroup(cgroup);
+        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_css(css);
 
         idx = MEMFILE_IDX(cft->private);
         name = MEMFILE_ATTR(cft->private);
@@ -300,10 +290,11 @@ static int hugetlb_cgroup_write(struct cgroup *cgroup, struct cftype *cft,
         return ret;
 }
 
-static int hugetlb_cgroup_reset(struct cgroup *cgroup, unsigned int event)
+static int hugetlb_cgroup_reset(struct cgroup_subsys_state *css,
+                                unsigned int event)
 {
         int idx, name, ret = 0;
-        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_cgroup(cgroup);
+        struct hugetlb_cgroup *h_cg = hugetlb_cgroup_from_css(css);
 
         idx = MEMFILE_IDX(event);
         name = MEMFILE_ATTR(event);
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 0878ff7c26a9..3b83957b6439 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -483,10 +483,9 @@ enum res_type {
  */
 static DEFINE_MUTEX(memcg_create_mutex);
 
-static inline
 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *s)
 {
-        return container_of(s, struct mem_cgroup, css);
+        return s ? container_of(s, struct mem_cgroup, css) : NULL;
 }
 
 /* Some nice accessors for the vmpressure. */
@@ -1035,12 +1034,6 @@ static void memcg_check_events(struct mem_cgroup *memcg, struct page *page)
                 preempt_enable();
 }
 
-struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont)
-{
-        return mem_cgroup_from_css(
-                cgroup_subsys_state(cont, mem_cgroup_subsys_id));
-}
-
 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
 {
         /*
@@ -1051,7 +1044,7 @@ struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
         if (unlikely(!p))
                 return NULL;
 
-        return mem_cgroup_from_css(task_subsys_state(p, mem_cgroup_subsys_id));
+        return mem_cgroup_from_css(task_css(p, mem_cgroup_subsys_id));
 }
 
 struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
@@ -1084,20 +1077,11 @@ struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
 static struct mem_cgroup *__mem_cgroup_iter_next(struct mem_cgroup *root,
                 struct mem_cgroup *last_visited)
 {
-        struct cgroup *prev_cgroup, *next_cgroup;
+        struct cgroup_subsys_state *prev_css, *next_css;
 
-        /*
-         * Root is not visited by cgroup iterators so it needs an
-         * explicit visit.
-         */
-        if (!last_visited)
-                return root;
-
-        prev_cgroup = (last_visited == root) ? NULL
-                : last_visited->css.cgroup;
+        prev_css = last_visited ? &last_visited->css : NULL;
 skip_node:
-        next_cgroup = cgroup_next_descendant_pre(
-                        prev_cgroup, root->css.cgroup);
+        next_css = css_next_descendant_pre(prev_css, &root->css);
 
         /*
          * Even if we found a group we have to make sure it is
@@ -1106,13 +1090,13 @@ skip_node:
          * last_visited css is safe to use because it is
          * protected by css_get and the tree walk is rcu safe.
          */
-        if (next_cgroup) {
-                struct mem_cgroup *mem = mem_cgroup_from_cont(
-                                next_cgroup);
+        if (next_css) {
+                struct mem_cgroup *mem = mem_cgroup_from_css(next_css);
+
                 if (css_tryget(&mem->css))
                         return mem;
                 else {
-                        prev_cgroup = next_cgroup;
+                        prev_css = next_css;
                         goto skip_node;
                 }
         }
@@ -1525,10 +1509,8 @@ static unsigned long mem_cgroup_margin(struct mem_cgroup *memcg)
 
 int mem_cgroup_swappiness(struct mem_cgroup *memcg)
 {
-        struct cgroup *cgrp = memcg->css.cgroup;
-
         /* root ? */
-        if (cgrp->parent == NULL)
+        if (!css_parent(&memcg->css))
                 return vm_swappiness;
 
         return memcg->swappiness;
@@ -1805,12 +1787,11 @@ static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
         check_panic_on_oom(CONSTRAINT_MEMCG, gfp_mask, order, NULL);
         totalpages = mem_cgroup_get_limit(memcg) >> PAGE_SHIFT ? : 1;
         for_each_mem_cgroup_tree(iter, memcg) {
-                struct cgroup *cgroup = iter->css.cgroup;
-                struct cgroup_iter it;
+                struct css_task_iter it;
                 struct task_struct *task;
 
-                cgroup_iter_start(cgroup, &it);
-                while ((task = cgroup_iter_next(cgroup, &it))) {
+                css_task_iter_start(&iter->css, &it);
+                while ((task = css_task_iter_next(&it))) {
                         switch (oom_scan_process_thread(task, totalpages, NULL,
                                                         false)) {
                         case OOM_SCAN_SELECT:
@@ -1823,7 +1804,7 @@ static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
                         case OOM_SCAN_CONTINUE:
                                 continue;
                         case OOM_SCAN_ABORT:
-                                cgroup_iter_end(cgroup, &it);
+                                css_task_iter_end(&it);
                                 mem_cgroup_iter_break(memcg, iter);
                                 if (chosen)
                                         put_task_struct(chosen);
@@ -1840,7 +1821,7 @@ static void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
                                 get_task_struct(chosen);
                         }
                 }
-                cgroup_iter_end(cgroup, &it);
+                css_task_iter_end(&it);
         }
 
         if (!chosen)
@@ -2954,10 +2935,10 @@ static struct kmem_cache *memcg_params_to_cache(struct memcg_cache_params *p)
 }
 
 #ifdef CONFIG_SLABINFO
-static int mem_cgroup_slabinfo_read(struct cgroup *cont, struct cftype *cft,
-                                        struct seq_file *m)
+static int mem_cgroup_slabinfo_read(struct cgroup_subsys_state *css,
+                                    struct cftype *cft, struct seq_file *m)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct memcg_cache_params *params;
 
         if (!memcg_can_account_kmem(memcg))
@@ -4943,10 +4924,10 @@ static void mem_cgroup_reparent_charges(struct mem_cgroup *memcg)
  */
 static inline bool __memcg_has_children(struct mem_cgroup *memcg)
 {
-        struct cgroup *pos;
+        struct cgroup_subsys_state *pos;
 
         /* bounce at first found */
-        cgroup_for_each_child(pos, memcg->css.cgroup)
+        css_for_each_child(pos, &memcg->css)
                 return true;
         return false;
 }
@@ -5002,9 +4983,10 @@ static int mem_cgroup_force_empty(struct mem_cgroup *memcg)
         return 0;
 }
 
-static int mem_cgroup_force_empty_write(struct cgroup *cont, unsigned int event)
+static int mem_cgroup_force_empty_write(struct cgroup_subsys_state *css,
+                                        unsigned int event)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         int ret;
 
         if (mem_cgroup_is_root(memcg))
@@ -5017,21 +4999,18 @@ static int mem_cgroup_force_empty_write(struct cgroup *cont, unsigned int event)
 }
 
 
-static u64 mem_cgroup_hierarchy_read(struct cgroup *cont, struct cftype *cft)
+static u64 mem_cgroup_hierarchy_read(struct cgroup_subsys_state *css,
+                                     struct cftype *cft)
 {
-        return mem_cgroup_from_cont(cont)->use_hierarchy;
+        return mem_cgroup_from_css(css)->use_hierarchy;
 }
 
-static int mem_cgroup_hierarchy_write(struct cgroup *cont, struct cftype *cft,
-                                        u64 val)
+static int mem_cgroup_hierarchy_write(struct cgroup_subsys_state *css,
+                                      struct cftype *cft, u64 val)
 {
         int retval = 0;
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
-        struct cgroup *parent = cont->parent;
-        struct mem_cgroup *parent_memcg = NULL;
-
-        if (parent)
-                parent_memcg = mem_cgroup_from_cont(parent);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
+        struct mem_cgroup *parent_memcg = mem_cgroup_from_css(css_parent(&memcg->css));
 
         mutex_lock(&memcg_create_mutex);
 
@@ -5101,11 +5080,11 @@ static inline u64 mem_cgroup_usage(struct mem_cgroup *memcg, bool swap)
         return val << PAGE_SHIFT;
 }
 
-static ssize_t mem_cgroup_read(struct cgroup *cont, struct cftype *cft,
-                               struct file *file, char __user *buf,
-                               size_t nbytes, loff_t *ppos)
+static ssize_t mem_cgroup_read(struct cgroup_subsys_state *css,
+                               struct cftype *cft, struct file *file,
+                               char __user *buf, size_t nbytes, loff_t *ppos)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         char str[64];
         u64 val;
         int name, len;
@@ -5138,11 +5117,11 @@ static ssize_t mem_cgroup_read(struct cgroup *cont, struct cftype *cft,
         return simple_read_from_buffer(buf, nbytes, ppos, str, len);
 }
 
-static int memcg_update_kmem_limit(struct cgroup *cont, u64 val)
+static int memcg_update_kmem_limit(struct cgroup_subsys_state *css, u64 val)
 {
         int ret = -EINVAL;
 #ifdef CONFIG_MEMCG_KMEM
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         /*
          * For simplicity, we won't allow this to be disabled.  It also can't
          * be changed if the cgroup has children already, or if tasks had
@@ -5158,7 +5137,7 @@ static int memcg_update_kmem_limit(struct cgroup *cont, u64 val)
         mutex_lock(&memcg_create_mutex);
         mutex_lock(&set_limit_mutex);
         if (!memcg->kmem_account_flags && val != RESOURCE_MAX) {
-                if (cgroup_task_count(cont) || memcg_has_children(memcg)) {
+                if (cgroup_task_count(css->cgroup) || memcg_has_children(memcg)) {
                         ret = -EBUSY;
                         goto out;
                 }
@@ -5228,10 +5207,10 @@ out:
  * The user of this function is...
  * RES_LIMIT.
  */
-static int mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
+static int mem_cgroup_write(struct cgroup_subsys_state *css, struct cftype *cft,
                             const char *buffer)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         enum res_type type;
         int name;
         unsigned long long val;
@@ -5255,7 +5234,7 @@ static int mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
                 else if (type == _MEMSWAP)
                         ret = mem_cgroup_resize_memsw_limit(memcg, val);
                 else if (type == _KMEM)
-                        ret = memcg_update_kmem_limit(cont, val);
+                        ret = memcg_update_kmem_limit(css, val);
                 else
                         return -EINVAL;
                 break;
@@ -5283,18 +5262,15 @@ static int mem_cgroup_write(struct cgroup *cont, struct cftype *cft,
 static void memcg_get_hierarchical_limit(struct mem_cgroup *memcg,
                 unsigned long long *mem_limit, unsigned long long *memsw_limit)
 {
-        struct cgroup *cgroup;
         unsigned long long min_limit, min_memsw_limit, tmp;
 
         min_limit = res_counter_read_u64(&memcg->res, RES_LIMIT);
         min_memsw_limit = res_counter_read_u64(&memcg->memsw, RES_LIMIT);
-        cgroup = memcg->css.cgroup;
         if (!memcg->use_hierarchy)
                 goto out;
 
-        while (cgroup->parent) {
-                cgroup = cgroup->parent;
-                memcg = mem_cgroup_from_cont(cgroup);
+        while (css_parent(&memcg->css)) {
+                memcg = mem_cgroup_from_css(css_parent(&memcg->css));
                 if (!memcg->use_hierarchy)
                         break;
                 tmp = res_counter_read_u64(&memcg->res, RES_LIMIT);
@@ -5307,9 +5283,9 @@ out:
         *memsw_limit = min_memsw_limit;
 }
 
-static int mem_cgroup_reset(struct cgroup *cont, unsigned int event)
+static int mem_cgroup_reset(struct cgroup_subsys_state *css, unsigned int event)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         int name;
         enum res_type type;
 
@@ -5342,17 +5318,17 @@ static int mem_cgroup_reset(struct cgroup *cont, unsigned int event)
         return 0;
 }
 
-static u64 mem_cgroup_move_charge_read(struct cgroup *cgrp,
+static u64 mem_cgroup_move_charge_read(struct cgroup_subsys_state *css,
                                         struct cftype *cft)
 {
-        return mem_cgroup_from_cont(cgrp)->move_charge_at_immigrate;
+        return mem_cgroup_from_css(css)->move_charge_at_immigrate;
 }
 
 #ifdef CONFIG_MMU
-static int mem_cgroup_move_charge_write(struct cgroup *cgrp,
+static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
                                         struct cftype *cft, u64 val)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         if (val >= (1 << NR_MOVE_TYPE))
                 return -EINVAL;
@@ -5367,7 +5343,7 @@ static int mem_cgroup_move_charge_write(struct cgroup *cgrp,
         return 0;
 }
 #else
-static int mem_cgroup_move_charge_write(struct cgroup *cgrp,
+static int mem_cgroup_move_charge_write(struct cgroup_subsys_state *css,
                                         struct cftype *cft, u64 val)
 {
         return -ENOSYS;
@@ -5375,13 +5351,13 @@ static int mem_cgroup_move_charge_write(struct cgroup *cgrp,
 #endif
 
 #ifdef CONFIG_NUMA
-static int memcg_numa_stat_show(struct cgroup *cont, struct cftype *cft,
-                                      struct seq_file *m)
+static int memcg_numa_stat_show(struct cgroup_subsys_state *css,
+                                struct cftype *cft, struct seq_file *m)
 {
         int nid;
         unsigned long total_nr, file_nr, anon_nr, unevictable_nr;
         unsigned long node_nr;
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         total_nr = mem_cgroup_nr_lru_pages(memcg, LRU_ALL);
         seq_printf(m, "total=%lu", total_nr);
@@ -5426,10 +5402,10 @@ static inline void mem_cgroup_lru_names_not_uptodate(void)
         BUILD_BUG_ON(ARRAY_SIZE(mem_cgroup_lru_names) != NR_LRU_LISTS);
 }
 
-static int memcg_stat_show(struct cgroup *cont, struct cftype *cft,
+static int memcg_stat_show(struct cgroup_subsys_state *css, struct cftype *cft,
                                  struct seq_file *m)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct mem_cgroup *mi;
         unsigned int i;
 
@@ -5513,27 +5489,23 @@ static int memcg_stat_show(struct cgroup *cont, struct cftype *cft,
         return 0;
 }
 
-static u64 mem_cgroup_swappiness_read(struct cgroup *cgrp, struct cftype *cft)
+static u64 mem_cgroup_swappiness_read(struct cgroup_subsys_state *css,
+                                      struct cftype *cft)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         return mem_cgroup_swappiness(memcg);
 }
 
-static int mem_cgroup_swappiness_write(struct cgroup *cgrp, struct cftype *cft,
-                                       u64 val)
+static int mem_cgroup_swappiness_write(struct cgroup_subsys_state *css,
+                                       struct cftype *cft, u64 val)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
-        struct mem_cgroup *parent;
-
-        if (val > 100)
-                return -EINVAL;
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
+        struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(&memcg->css));
 
-        if (cgrp->parent == NULL)
+        if (val > 100 || !parent)
                 return -EINVAL;
 
-        parent = mem_cgroup_from_cont(cgrp->parent);
-
         mutex_lock(&memcg_create_mutex);
 
         /* If under hierarchy, only empty-root can set this value */
@@ -5636,10 +5608,10 @@ static void mem_cgroup_oom_notify(struct mem_cgroup *memcg)
                 mem_cgroup_oom_notify_cb(iter);
 }
 
-static int mem_cgroup_usage_register_event(struct cgroup *cgrp,
+static int mem_cgroup_usage_register_event(struct cgroup_subsys_state *css,
         struct cftype *cft, struct eventfd_ctx *eventfd, const char *args)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct mem_cgroup_thresholds *thresholds;
         struct mem_cgroup_threshold_ary *new;
         enum res_type type = MEMFILE_TYPE(cft->private);
@@ -5719,10 +5691,10 @@ unlock:
         return ret;
 }
 
-static void mem_cgroup_usage_unregister_event(struct cgroup *cgrp,
+static void mem_cgroup_usage_unregister_event(struct cgroup_subsys_state *css,
         struct cftype *cft, struct eventfd_ctx *eventfd)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct mem_cgroup_thresholds *thresholds;
         struct mem_cgroup_threshold_ary *new;
         enum res_type type = MEMFILE_TYPE(cft->private);
@@ -5798,10 +5770,10 @@ unlock:
         mutex_unlock(&memcg->thresholds_lock);
 }
 
-static int mem_cgroup_oom_register_event(struct cgroup *cgrp,
+static int mem_cgroup_oom_register_event(struct cgroup_subsys_state *css,
         struct cftype *cft, struct eventfd_ctx *eventfd, const char *args)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct mem_cgroup_eventfd_list *event;
         enum res_type type = MEMFILE_TYPE(cft->private);
 
@@ -5823,10 +5795,10 @@ static int mem_cgroup_oom_register_event(struct cgroup *cgrp,
         return 0;
 }
 
-static void mem_cgroup_oom_unregister_event(struct cgroup *cgrp,
+static void mem_cgroup_oom_unregister_event(struct cgroup_subsys_state *css,
         struct cftype *cft, struct eventfd_ctx *eventfd)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         struct mem_cgroup_eventfd_list *ev, *tmp;
         enum res_type type = MEMFILE_TYPE(cft->private);
 
@@ -5844,10 +5816,10 @@ static void mem_cgroup_oom_unregister_event(struct cgroup *cgrp,
         spin_unlock(&memcg_oom_lock);
 }
 
-static int mem_cgroup_oom_control_read(struct cgroup *cgrp,
+static int mem_cgroup_oom_control_read(struct cgroup_subsys_state *css,
         struct cftype *cft,  struct cgroup_map_cb *cb)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         cb->fill(cb, "oom_kill_disable", memcg->oom_kill_disable);
 
@@ -5858,18 +5830,16 @@ static int mem_cgroup_oom_control_read(struct cgroup *cgrp,
         return 0;
 }
 
-static int mem_cgroup_oom_control_write(struct cgroup *cgrp,
+static int mem_cgroup_oom_control_write(struct cgroup_subsys_state *css,
         struct cftype *cft, u64 val)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
-        struct mem_cgroup *parent;
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
+        struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(&memcg->css));
 
         /* cannot set to root cgroup and only 0 and 1 are allowed */
-        if (!cgrp->parent || !((val == 0) || (val == 1)))
+        if (!parent || !((val == 0) || (val == 1)))
                 return -EINVAL;
 
-        parent = mem_cgroup_from_cont(cgrp->parent);
-
         mutex_lock(&memcg_create_mutex);
         /* oom-kill-disable is a flag for subhierarchy. */
         if ((parent->use_hierarchy) || memcg_has_children(memcg)) {
@@ -6228,7 +6198,7 @@ static void __init mem_cgroup_soft_limit_tree_init(void)
 }
 
 static struct cgroup_subsys_state * __ref
-mem_cgroup_css_alloc(struct cgroup *cont)
+mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
 {
         struct mem_cgroup *memcg;
         long error = -ENOMEM;
@@ -6243,7 +6213,7 @@ mem_cgroup_css_alloc(struct cgroup *cont)
                         goto free_out;
 
         /* root ? */
-        if (cont->parent == NULL) {
+        if (parent_css == NULL) {
                 root_mem_cgroup = memcg;
                 res_counter_init(&memcg->res, NULL);
                 res_counter_init(&memcg->memsw, NULL);
@@ -6265,17 +6235,16 @@ free_out:
 }
 
 static int
-mem_cgroup_css_online(struct cgroup *cont)
+mem_cgroup_css_online(struct cgroup_subsys_state *css)
 {
-        struct mem_cgroup *memcg, *parent;
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
+        struct mem_cgroup *parent = mem_cgroup_from_css(css_parent(css));
         int error = 0;
 
-        if (!cont->parent)
+        if (!parent)
                 return 0;
 
         mutex_lock(&memcg_create_mutex);
-        memcg = mem_cgroup_from_cont(cont);
-        parent = mem_cgroup_from_cont(cont->parent);
 
         memcg->use_hierarchy = parent->use_hierarchy;
         memcg->oom_kill_disable = parent->oom_kill_disable;
@@ -6326,9 +6295,9 @@ static void mem_cgroup_invalidate_reclaim_iterators(struct mem_cgroup *memcg)
                 mem_cgroup_iter_invalidate(root_mem_cgroup);
 }
 
-static void mem_cgroup_css_offline(struct cgroup *cont)
+static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         kmem_cgroup_css_offline(memcg);
 
@@ -6338,9 +6307,9 @@ static void mem_cgroup_css_offline(struct cgroup *cont)
         vmpressure_cleanup(&memcg->vmpressure);
 }
 
-static void mem_cgroup_css_free(struct cgroup *cont)
+static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
 {
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cont);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         memcg_destroy_kmem(memcg);
         __mem_cgroup_free(memcg);
@@ -6710,12 +6679,12 @@ static void mem_cgroup_clear_mc(void)
         mem_cgroup_end_move(from);
 }
 
-static int mem_cgroup_can_attach(struct cgroup *cgroup,
+static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
                                  struct cgroup_taskset *tset)
 {
         struct task_struct *p = cgroup_taskset_first(tset);
         int ret = 0;
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cgroup);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
         unsigned long move_charge_at_immigrate;
 
         /*
@@ -6757,7 +6726,7 @@ static int mem_cgroup_can_attach(struct cgroup *cgroup,
         return ret;
 }
 
-static void mem_cgroup_cancel_attach(struct cgroup *cgroup,
+static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
                                      struct cgroup_taskset *tset)
 {
         mem_cgroup_clear_mc();
@@ -6905,7 +6874,7 @@ retry:
         up_read(&mm->mmap_sem);
 }
 
-static void mem_cgroup_move_task(struct cgroup *cont,
+static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
                                  struct cgroup_taskset *tset)
 {
         struct task_struct *p = cgroup_taskset_first(tset);
@@ -6920,16 +6889,16 @@ static void mem_cgroup_move_task(struct cgroup *cont,
                 mem_cgroup_clear_mc();
 }
 #else   /* !CONFIG_MMU */
-static int mem_cgroup_can_attach(struct cgroup *cgroup,
+static int mem_cgroup_can_attach(struct cgroup_subsys_state *css,
                                  struct cgroup_taskset *tset)
 {
         return 0;
 }
-static void mem_cgroup_cancel_attach(struct cgroup *cgroup,
+static void mem_cgroup_cancel_attach(struct cgroup_subsys_state *css,
                                      struct cgroup_taskset *tset)
 {
 }
-static void mem_cgroup_move_task(struct cgroup *cont,
+static void mem_cgroup_move_task(struct cgroup_subsys_state *css,
                                  struct cgroup_taskset *tset)
 {
 }
@@ -6939,15 +6908,15 @@ static void mem_cgroup_move_task(struct cgroup *cont,
  * Cgroup retains root cgroups across [un]mount cycles making it necessary
  * to verify sane_behavior flag on each mount attempt.
  */
-static void mem_cgroup_bind(struct cgroup *root)
+static void mem_cgroup_bind(struct cgroup_subsys_state *root_css)
 {
         /*
          * use_hierarchy is forced with sane_behavior.  cgroup core
          * guarantees that @root doesn't have any children, so turning it
          * on for the root memcg is enough.
          */
-        if (cgroup_sane_behavior(root))
-                mem_cgroup_from_cont(root)->use_hierarchy = true;
+        if (cgroup_sane_behavior(root_css->cgroup))
+                mem_cgroup_from_css(root_css)->use_hierarchy = true;
 }
 
 struct cgroup_subsys mem_cgroup_subsys = {
diff --git a/mm/vmpressure.c b/mm/vmpressure.c
index 0c1e37d829fa..e0f62837c3f4 100644
--- a/mm/vmpressure.c
+++ b/mm/vmpressure.c
@@ -74,15 +74,10 @@ static struct vmpressure *work_to_vmpressure(struct work_struct *work)
         return container_of(work, struct vmpressure, work);
 }
 
-static struct vmpressure *cg_to_vmpressure(struct cgroup *cg)
-{
-        return css_to_vmpressure(cgroup_subsys_state(cg, mem_cgroup_subsys_id));
-}
-
 static struct vmpressure *vmpressure_parent(struct vmpressure *vmpr)
 {
-        struct cgroup *cg = vmpressure_to_css(vmpr)->cgroup;
-        struct mem_cgroup *memcg = mem_cgroup_from_cont(cg);
+        struct cgroup_subsys_state *css = vmpressure_to_css(vmpr);
+        struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 
         memcg = parent_mem_cgroup(memcg);
         if (!memcg)
@@ -283,7 +278,7 @@ void vmpressure_prio(gfp_t gfp, struct mem_cgroup *memcg, int prio)
 
 /**
  * vmpressure_register_event() - Bind vmpressure notifications to an eventfd
- * @cg:         cgroup that is interested in vmpressure notifications
+ * @css:        css that is interested in vmpressure notifications
  * @cft:        cgroup control files handle
  * @eventfd:    eventfd context to link notifications with
  * @args:       event arguments (used to set up a pressure level threshold)
@@ -298,10 +293,11 @@ void vmpressure_prio(gfp_t gfp, struct mem_cgroup *memcg, int prio)
  * cftype).register_event, and then cgroup core will handle everything by
  * itself.
  */
-int vmpressure_register_event(struct cgroup *cg, struct cftype *cft,
-                              struct eventfd_ctx *eventfd, const char *args)
+int vmpressure_register_event(struct cgroup_subsys_state *css,
+                              struct cftype *cft, struct eventfd_ctx *eventfd,
+                              const char *args)
 {
-        struct vmpressure *vmpr = cg_to_vmpressure(cg);
+        struct vmpressure *vmpr = css_to_vmpressure(css);
         struct vmpressure_event *ev;
         int level;
 
@@ -329,7 +325,7 @@ int vmpressure_register_event(struct cgroup *cg, struct cftype *cft,
 
 /**
  * vmpressure_unregister_event() - Unbind eventfd from vmpressure
- * @cg:         cgroup handle
+ * @css:        css handle
  * @cft:        cgroup control files handle
  * @eventfd:    eventfd context that was used to link vmpressure with the @cg
  *
@@ -341,10 +337,11 @@ int vmpressure_register_event(struct cgroup *cg, struct cftype *cft,
  * cftype).unregister_event, and then cgroup core will handle everything
  * by itself.
  */
-void vmpressure_unregister_event(struct cgroup *cg, struct cftype *cft,
+void vmpressure_unregister_event(struct cgroup_subsys_state *css,
+                                 struct cftype *cft,
                                  struct eventfd_ctx *eventfd)
 {
-        struct vmpressure *vmpr = cg_to_vmpressure(cg);
+        struct vmpressure *vmpr = css_to_vmpressure(css);
         struct vmpressure_event *ev;
 
         mutex_lock(&vmpr->events_lock);