Merge remote-tracking branch 'cgroup/for-next'

Conflicts:
	mm/memcontrol.c

diff --cc block/blk-cgroup.c
Simple merge

diff --cc block/cfq-iosched.c
Simple merge

diff --cc fs/bio.c
Simple merge

diff --cc fs/kernfs/dir.c
Simple merge

diff --cc init/Kconfig
Simple merge

diff --cc kernel/cgroup.c
index 105f273b6f86a74984d2b62b7d3ba19f95369a78,306ad0ed19efdc14aebc62f5b72661d3194fc19a..8f4ddbe23d58bd6addf8a0bebe5641ec76acf4be
--- 1/kernel/cgroup.c
--- 2/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@@ -1658,27 -1527,52 +1527,52 @@@ retry
                                pr_warning("cgroup: new mount options do not match the existing superblock, will be ignored\n");
                        }
                }
+ 
+               /*
+                * A root's lifetime is governed by its top cgroup.  Zero
+                * ref indicate that the root is being destroyed.  Wait for
+                * destruction to complete so that the subsystems are free.
+                * We can use wait_queue for the wait but this path is
+                * super cold.  Let's just sleep for a bit and retry.
+                */
+               if (!atomic_inc_not_zero(&root->top_cgroup.refcnt)) {
+                       mutex_unlock(&cgroup_mutex);
+                       mutex_unlock(&cgroup_tree_mutex);
+                       kfree(opts.release_agent);
+                       kfree(opts.name);
+                       msleep(10);
+                       goto retry;
+               }
+ 
+               ret = 0;
+               goto out_unlock;
        }
  
-       kfree(opts.release_agent);
-       kfree(opts.name);
-       return dget(sb->s_root);
+       /* no such thing, create a new one */
+       root = cgroup_root_from_opts(&opts);
+       if (IS_ERR(root)) {
+               ret = PTR_ERR(root);
+               goto out_unlock;
+       }
  
-  rm_base_files:
-       free_cgrp_cset_links(&tmp_links);
-       cgroup_addrm_files(&root->top_cgroup, cgroup_base_files, false);
-       revert_creds(cred);
-  unlock_drop:
-       cgroup_exit_root_id(root);
-       mutex_unlock(&cgroup_root_mutex);
+       ret = cgroup_setup_root(root, opts.subsys_mask);
+       if (ret)
+               cgroup_free_root(root);
+ 
+ out_unlock:
        mutex_unlock(&cgroup_mutex);
-       mutex_unlock(&inode->i_mutex);
-  drop_new_super:
-       deactivate_locked_super(sb);
-  out_err:
+       mutex_unlock(&cgroup_tree_mutex);
+ 
        kfree(opts.release_agent);
        kfree(opts.name);
-       return ERR_PTR(ret);
+ 
+       if (ret)
+               return ERR_PTR(ret);
+ 
 -      dentry = kernfs_mount(fs_type, flags, root->kf_root);
++      dentry = kernfs_mount(fs_type, flags, root->kf_root, NULL);
+       if (IS_ERR(dentry))
+               cgroup_put(&root->top_cgroup);
+       return dentry;
  }
  
  static void cgroup_kill_sb(struct super_block *sb)

diff --cc kernel/events/core.c
Simple merge

diff --cc kernel/sched/core.c
Simple merge

diff --cc kernel/sched/debug.c
Simple merge

diff --cc mm/memcontrol.c
index 5b6b0039f725032de5d63376aa0388e49bd3192d,d9c6ac1532e64a0dd06be9f36859c35551a15ccc..483d02886bbf9833e563d0e4dd3ebfca0d68c0ff
--- 1/mm/memcontrol.c
--- 2/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@@ -1683,54 -1683,25 +1683,25 @@@ static void move_unlock_mem_cgroup(stru
   */
  void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
  {
-       /*
-        * protects memcg_name and makes sure that parallel ooms do not
-        * interleave
-        */
+       /* oom_info_lock ensures that parallel ooms do not interleave */
 -      static DEFINE_SPINLOCK(oom_info_lock);
 +      static DEFINE_MUTEX(oom_info_lock);
-       struct cgroup *task_cgrp;
-       struct cgroup *mem_cgrp;
-       static char memcg_name[PATH_MAX];
-       int ret;
        struct mem_cgroup *iter;
        unsigned int i;
  
        if (!p)
                return;
  
 -      spin_lock(&oom_info_lock);
 +      mutex_lock(&oom_info_lock);
        rcu_read_lock();
  
-       mem_cgrp = memcg->css.cgroup;
-       task_cgrp = task_cgroup(p, mem_cgroup_subsys_id);
- 
-       ret = cgroup_path(task_cgrp, memcg_name, PATH_MAX);
-       if (ret < 0) {
-               /*
-                * Unfortunately, we are unable to convert to a useful name
-                * But we'll still print out the usage information
-                */
-               rcu_read_unlock();
-               goto done;
-       }
-       rcu_read_unlock();
- 
-       pr_info("Task in %s killed", memcg_name);
+       pr_info("Task in ");
+       pr_cont_cgroup_path(task_cgroup(p, memory_cgrp_id));
+       pr_info(" killed as a result of limit of ");
+       pr_cont_cgroup_path(memcg->css.cgroup);
+       pr_info("\n");
  
-       rcu_read_lock();
-       ret = cgroup_path(mem_cgrp, memcg_name, PATH_MAX);
-       if (ret < 0) {
-               rcu_read_unlock();
-               goto done;
-       }
        rcu_read_unlock();
  
-       /*
-        * Continues from above, so we don't need an KERN_ level
-        */
-       pr_cont(" as a result of limit of %s\n", memcg_name);
- done:
- 
        pr_info("memory: usage %llukB, limit %llukB, failcnt %llu\n",
                res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
                res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,

diff --cc mm/memory-failure.c
Simple merge