/*
  * cgroup-v1.c
  */
-extern struct cftype cgroup_legacy_base_files[];
+extern struct cftype cgroup1_base_files[];
 extern const struct file_operations proc_cgroupstats_operations;
 extern struct kernfs_syscall_ops cgroup1_kf_syscall_ops;
 
-bool cgroup_ssid_no_v1(int ssid);
-void cgroup_pidlist_destroy_all(struct cgroup *cgrp);
-void cgroup_release_agent(struct work_struct *work);
-void check_for_release(struct cgroup *cgrp);
+bool cgroup1_ssid_disabled(int ssid);
+void cgroup1_pidlist_destroy_all(struct cgroup *cgrp);
+void cgroup1_release_agent(struct work_struct *work);
+void cgroup1_check_for_release(struct cgroup *cgrp);
 struct dentry *cgroup1_mount(struct file_system_type *fs_type, int flags,
                             void *data, unsigned long magic,
                             struct cgroup_namespace *ns);
 
  */
 static DEFINE_SPINLOCK(release_agent_path_lock);
 
-bool cgroup_ssid_no_v1(int ssid)
+bool cgroup1_ssid_disabled(int ssid)
 {
        return cgroup_no_v1_mask & (1 << ssid);
 }
  * Used to destroy all pidlists lingering waiting for destroy timer.  None
  * should be left afterwards.
  */
-void cgroup_pidlist_destroy_all(struct cgroup *cgrp)
+void cgroup1_pidlist_destroy_all(struct cgroup *cgrp)
 {
        struct cgroup_pidlist *l, *tmp_l;
 
 }
 
 /* cgroup core interface files for the legacy hierarchies */
-struct cftype cgroup_legacy_base_files[] = {
+struct cftype cgroup1_base_files[] = {
        {
                .name = "cgroup.procs",
                .seq_start = cgroup_pidlist_start,
        return 0;
 }
 
-void check_for_release(struct cgroup *cgrp)
+void cgroup1_check_for_release(struct cgroup *cgrp)
 {
        if (notify_on_release(cgrp) && !cgroup_is_populated(cgrp) &&
            !css_has_online_children(&cgrp->self) && !cgroup_is_dead(cgrp))
  * this routine has no use for the exit status of the release agent
  * task, so no sense holding our caller up for that.
  */
-void cgroup_release_agent(struct work_struct *work)
+void cgroup1_release_agent(struct work_struct *work)
 {
        struct cgroup *cgrp =
                container_of(work, struct cgroup, release_agent_work);
                                continue;
                        if (!cgroup_ssid_enabled(i))
                                continue;
-                       if (cgroup_ssid_no_v1(i))
+                       if (cgroup1_ssid_disabled(i))
                                continue;
 
                        /* Mutually exclusive option 'all' + subsystem name */
         */
        if (all_ss || (!one_ss && !opts->none && !opts->name))
                for_each_subsys(ss, i)
-                       if (cgroup_ssid_enabled(i) && !cgroup_ssid_no_v1(i))
+                       if (cgroup_ssid_enabled(i) && !cgroup1_ssid_disabled(i))
                                opts->subsys_mask |= (1 << i);
 
        /*
 
 static u16 have_canfork_callback __read_mostly;
 
 static struct file_system_type cgroup2_fs_type;
-static struct cftype cgroup_dfl_base_files[];
+static struct cftype cgroup_base_files[];
 
 static int cgroup_apply_control(struct cgroup *cgrp);
 static void cgroup_finalize_control(struct cgroup *cgrp, int ret);
                if (!trigger)
                        break;
 
-               check_for_release(cgrp);
+               cgroup1_check_for_release(cgrp);
                cgroup_file_notify(&cgrp->events_file);
 
                cgrp = cgroup_parent(cgrp);
 
        if (!css->ss) {
                if (cgroup_on_dfl(cgrp))
-                       cfts = cgroup_dfl_base_files;
+                       cfts = cgroup_base_files;
                else
-                       cfts = cgroup_legacy_base_files;
+                       cfts = cgroup1_base_files;
 
                return cgroup_addrm_files(&cgrp->self, cgrp, cfts, true);
        }
                INIT_LIST_HEAD(&cgrp->e_csets[ssid]);
 
        init_waitqueue_head(&cgrp->offline_waitq);
-       INIT_WORK(&cgrp->release_agent_work, cgroup_release_agent);
+       INIT_WORK(&cgrp->release_agent_work, cgroup1_release_agent);
 }
 
 void init_cgroup_root(struct cgroup_root *root, struct cgroup_sb_opts *opts)
 }
 
 /* cgroup core interface files for the default hierarchy */
-static struct cftype cgroup_dfl_base_files[] = {
+static struct cftype cgroup_base_files[] = {
        {
                .name = "cgroup.procs",
                .file_offset = offsetof(struct cgroup, procs_file),
        } else {
                /* cgroup free path */
                atomic_dec(&cgrp->root->nr_cgrps);
-               cgroup_pidlist_destroy_all(cgrp);
+               cgroup1_pidlist_destroy_all(cgrp);
                cancel_work_sync(&cgrp->release_agent_work);
 
                if (cgroup_parent(cgrp)) {
         */
        kernfs_remove(cgrp->kn);
 
-       check_for_release(cgroup_parent(cgrp));
+       cgroup1_check_for_release(cgroup_parent(cgrp));
 
        /* put the base reference */
        percpu_ref_kill(&cgrp->self.refcnt);
 
        BUILD_BUG_ON(CGROUP_SUBSYS_COUNT > 16);
        BUG_ON(percpu_init_rwsem(&cgroup_threadgroup_rwsem));
-       BUG_ON(cgroup_init_cftypes(NULL, cgroup_dfl_base_files));
-       BUG_ON(cgroup_init_cftypes(NULL, cgroup_legacy_base_files));
+       BUG_ON(cgroup_init_cftypes(NULL, cgroup_base_files));
+       BUG_ON(cgroup_init_cftypes(NULL, cgroup1_base_files));
 
        /*
         * The latency of the synchronize_sched() is too high for cgroups,
                        continue;
                }
 
-               if (cgroup_ssid_no_v1(ssid))
+               if (cgroup1_ssid_disabled(ssid))
                        printk(KERN_INFO "Disabling %s control group subsystem in v1 mounts\n",
                               ss->name);