*/
 struct cgroup_fs_context {
        struct cgroup_root      *root;
+       struct cgroup_namespace *ns;
        unsigned int    flags;                  /* CGRP_ROOT_* flags */
 
        /* cgroup1 bits */
 void init_cgroup_root(struct cgroup_fs_context *ctx);
 int cgroup_setup_root(struct cgroup_root *root, u16 ss_mask);
 int rebind_subsystems(struct cgroup_root *dst_root, u16 ss_mask);
-int cgroup_do_mount(struct fs_context *fc, unsigned long magic,
-                              struct cgroup_namespace *ns);
+int cgroup_do_get_tree(struct fs_context *fc);
 
 int cgroup_migrate_vet_dst(struct cgroup *dst_cgrp);
 void cgroup_migrate_finish(struct cgroup_mgctx *mgctx);
 
  */
 static int cgroup1_root_to_use(struct fs_context *fc)
 {
-       struct cgroup_namespace *ns = current->nsproxy->cgroup_ns;
        struct cgroup_fs_context *ctx = cgroup_fc2context(fc);
        struct cgroup_root *root;
        struct cgroup_subsys *ss;
                return cg_invalf(fc, "cgroup1: No subsys list or none specified");
 
        /* Hierarchies may only be created in the initial cgroup namespace. */
-       if (ns != &init_cgroup_ns)
+       if (ctx->ns != &init_cgroup_ns)
                return -EPERM;
 
        root = kzalloc(sizeof(*root), GFP_KERNEL);
 
 int cgroup1_get_tree(struct fs_context *fc)
 {
-       struct cgroup_namespace *ns = current->nsproxy->cgroup_ns;
        struct cgroup_fs_context *ctx = cgroup_fc2context(fc);
        int ret;
 
        /* Check if the caller has permission to mount. */
-       if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN))
+       if (!ns_capable(ctx->ns->user_ns, CAP_SYS_ADMIN))
                return -EPERM;
 
        cgroup_lock_and_drain_offline(&cgrp_dfl_root.cgrp);
        mutex_unlock(&cgroup_mutex);
 
        if (!ret)
-               ret = cgroup_do_mount(fc, CGROUP_SUPER_MAGIC, ns);
+               ret = cgroup_do_get_tree(fc);
 
        if (!ret && percpu_ref_is_dying(&ctx->root->cgrp.self.refcnt)) {
                struct super_block *sb = fc->root->d_sb;
 
        return ret;
 }
 
-int cgroup_do_mount(struct fs_context *fc, unsigned long magic,
-                   struct cgroup_namespace *ns)
+int cgroup_do_get_tree(struct fs_context *fc)
 {
        struct cgroup_fs_context *ctx = cgroup_fc2context(fc);
        bool new_sb = false;
+       unsigned long magic;
        int ret = 0;
 
+       if (fc->fs_type == &cgroup2_fs_type)
+               magic = CGROUP2_SUPER_MAGIC;
+       else
+               magic = CGROUP_SUPER_MAGIC;
        fc->root = kernfs_mount(fc->fs_type, fc->sb_flags, ctx->root->kf_root,
                                magic, &new_sb);
        if (IS_ERR(fc->root))
         * In non-init cgroup namespace, instead of root cgroup's dentry,
         * we return the dentry corresponding to the cgroupns->root_cgrp.
         */
-       if (!ret && ns != &init_cgroup_ns) {
+       if (!ret && ctx->ns != &init_cgroup_ns) {
                struct dentry *nsdentry;
                struct super_block *sb = fc->root->d_sb;
                struct cgroup *cgrp;
                mutex_lock(&cgroup_mutex);
                spin_lock_irq(&css_set_lock);
 
-               cgrp = cset_cgroup_from_root(ns->root_cset, ctx->root);
+               cgrp = cset_cgroup_from_root(ctx->ns->root_cset, ctx->root);
 
                spin_unlock_irq(&css_set_lock);
                mutex_unlock(&cgroup_mutex);
 
        kfree(ctx->name);
        kfree(ctx->release_agent);
+       put_cgroup_ns(ctx->ns);
        kfree(ctx);
 }
 
        cgroup_get_live(&cgrp_dfl_root.cgrp);
        ctx->root = &cgrp_dfl_root;
 
-       ret = cgroup_do_mount(fc, CGROUP2_SUPER_MAGIC, ns);
+       ret = cgroup_do_get_tree(fc);
        if (!ret)
                apply_cgroup_root_flags(ctx->flags);
        return ret;
        if (!use_task_css_set_links)
                cgroup_enable_task_cg_lists();
 
+       ctx->ns = current->nsproxy->cgroup_ns;
+       get_cgroup_ns(ctx->ns);
        fc->fs_private = ctx;
        if (fc->fs_type == &cgroup2_fs_type)
                fc->ops = &cgroup_fs_context_ops;