memcg: cleanup kmem cache creation/destruction functions naming

Current names are rather inconsistent. Let's try to improve them.

Brief change log:

** old name **                          ** new name **

kmem_cache_create_memcg                 memcg_create_kmem_cache
memcg_kmem_create_cache                 memcg_regsiter_cache
memcg_kmem_destroy_cache                memcg_unregister_cache

kmem_cache_destroy_memcg_children       memcg_cleanup_cache_params
mem_cgroup_destroy_all_caches           memcg_unregister_all_caches

create_work                             memcg_register_cache_work
memcg_create_cache_work_func            memcg_register_cache_func
memcg_create_cache_enqueue              memcg_schedule_register_cache

Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Acked-by: Michal Hocko <mhocko@suse.cz>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 28 insertions, 32 deletions

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 5e2bfcc96da9..d176edb1d5e8 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -3132,8 +3132,8 @@ void memcg_free_cache_params(struct kmem_cache *s)
         kfree(s->memcg_params);
 }
 
-static void memcg_kmem_create_cache(struct mem_cgroup *memcg,
-                                    struct kmem_cache *root_cache)
+static void memcg_register_cache(struct mem_cgroup *memcg,
+                                 struct kmem_cache *root_cache)
 {
         static char memcg_name_buf[NAME_MAX + 1]; /* protected by
                                                      memcg_slab_mutex */
@@ -3153,7 +3153,7 @@ static void memcg_kmem_create_cache(struct mem_cgroup *memcg,
                 return;
 
         cgroup_name(memcg->css.cgroup, memcg_name_buf, NAME_MAX + 1);
-        cachep = kmem_cache_create_memcg(memcg, root_cache, memcg_name_buf);
+        cachep = memcg_create_kmem_cache(memcg, root_cache, memcg_name_buf);
         /*
          * If we could not create a memcg cache, do not complain, because
          * that's not critical at all as we can always proceed with the root
@@ -3175,7 +3175,7 @@ static void memcg_kmem_create_cache(struct mem_cgroup *memcg,
         root_cache->memcg_params->memcg_caches[id] = cachep;
 }
 
-static void memcg_kmem_destroy_cache(struct kmem_cache *cachep)
+static void memcg_unregister_cache(struct kmem_cache *cachep)
 {
         struct kmem_cache *root_cache;
         struct mem_cgroup *memcg;
@@ -3228,7 +3228,7 @@ static inline void memcg_resume_kmem_account(void)
         current->memcg_kmem_skip_account--;
 }
 
-int __kmem_cache_destroy_memcg_children(struct kmem_cache *s)
+int __memcg_cleanup_cache_params(struct kmem_cache *s)
 {
         struct kmem_cache *c;
         int i, failed = 0;
@@ -3239,7 +3239,7 @@ int __kmem_cache_destroy_memcg_children(struct kmem_cache *s)
                 if (!c)
                         continue;
 
-                memcg_kmem_destroy_cache(c);
+                memcg_unregister_cache(c);
 
                 if (cache_from_memcg_idx(s, i))
                         failed++;
@@ -3248,7 +3248,7 @@ int __kmem_cache_destroy_memcg_children(struct kmem_cache *s)
         return failed;
 }
 
-static void mem_cgroup_destroy_all_caches(struct mem_cgroup *memcg)
+static void memcg_unregister_all_caches(struct mem_cgroup *memcg)
 {
         struct kmem_cache *cachep;
         struct memcg_cache_params *params, *tmp;
@@ -3261,25 +3261,26 @@ static void mem_cgroup_destroy_all_caches(struct mem_cgroup *memcg)
                 cachep = memcg_params_to_cache(params);
                 kmem_cache_shrink(cachep);
                 if (atomic_read(&cachep->memcg_params->nr_pages) == 0)
-                        memcg_kmem_destroy_cache(cachep);
+                        memcg_unregister_cache(cachep);
         }
         mutex_unlock(&memcg_slab_mutex);
 }
 
-struct create_work {
+struct memcg_register_cache_work {
         struct mem_cgroup *memcg;
         struct kmem_cache *cachep;
         struct work_struct work;
 };
 
-static void memcg_create_cache_work_func(struct work_struct *w)
+static void memcg_register_cache_func(struct work_struct *w)
 {
-        struct create_work *cw = container_of(w, struct create_work, work);
+        struct memcg_register_cache_work *cw =
+                container_of(w, struct memcg_register_cache_work, work);
         struct mem_cgroup *memcg = cw->memcg;
         struct kmem_cache *cachep = cw->cachep;
 
         mutex_lock(&memcg_slab_mutex);
-        memcg_kmem_create_cache(memcg, cachep);
+        memcg_register_cache(memcg, cachep);
         mutex_unlock(&memcg_slab_mutex);
 
         css_put(&memcg->css);
@@ -3289,12 +3290,12 @@ static void memcg_create_cache_work_func(struct work_struct *w)
 /*
  * Enqueue the creation of a per-memcg kmem_cache.
  */
-static void __memcg_create_cache_enqueue(struct mem_cgroup *memcg,
-                                         struct kmem_cache *cachep)
+static void __memcg_schedule_register_cache(struct mem_cgroup *memcg,
+                                            struct kmem_cache *cachep)
 {
-        struct create_work *cw;
+        struct memcg_register_cache_work *cw;
 
-        cw = kmalloc(sizeof(struct create_work), GFP_NOWAIT);
+        cw = kmalloc(sizeof(*cw), GFP_NOWAIT);
         if (cw == NULL) {
                 css_put(&memcg->css);
                 return;
@@ -3303,17 +3304,17 @@ static void __memcg_create_cache_enqueue(struct mem_cgroup *memcg,
         cw->memcg = memcg;
         cw->cachep = cachep;
 
-        INIT_WORK(&cw->work, memcg_create_cache_work_func);
+        INIT_WORK(&cw->work, memcg_register_cache_func);
         schedule_work(&cw->work);
 }
 
-static void memcg_create_cache_enqueue(struct mem_cgroup *memcg,
-                                       struct kmem_cache *cachep)
+static void memcg_schedule_register_cache(struct mem_cgroup *memcg,
+                                          struct kmem_cache *cachep)
 {
         /*
          * We need to stop accounting when we kmalloc, because if the
          * corresponding kmalloc cache is not yet created, the first allocation
-         * in __memcg_create_cache_enqueue will recurse.
+         * in __memcg_schedule_register_cache will recurse.
          *
          * However, it is better to enclose the whole function. Depending on
          * the debugging options enabled, INIT_WORK(), for instance, can
@@ -3322,7 +3323,7 @@ static void memcg_create_cache_enqueue(struct mem_cgroup *memcg,
          * the safest choice is to do it like this, wrapping the whole function.
          */
         memcg_stop_kmem_account();
-        __memcg_create_cache_enqueue(memcg, cachep);
+        __memcg_schedule_register_cache(memcg, cachep);
         memcg_resume_kmem_account();
 }
 
@@ -3393,16 +3394,11 @@ struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep,
          *
          * However, there are some clashes that can arrive from locking.
          * For instance, because we acquire the slab_mutex while doing
-         * kmem_cache_dup, this means no further allocation could happen
-         * with the slab_mutex held.
-         *
-         * Also, because cache creation issue get_online_cpus(), this
-         * creates a lock chain: memcg_slab_mutex -> cpu_hotplug_mutex,
-         * that ends up reversed during cpu hotplug. (cpuset allocates
-         * a bunch of GFP_KERNEL memory during cpuup). Due to all that,
-         * better to defer everything.
+         * memcg_create_kmem_cache, this means no further allocation
+         * could happen with the slab_mutex held. So it's better to
+         * defer everything.
          */
-        memcg_create_cache_enqueue(memcg, cachep);
+        memcg_schedule_register_cache(memcg, cachep);
         return cachep;
 out:
         rcu_read_unlock();
@@ -3526,7 +3522,7 @@ void __memcg_kmem_uncharge_pages(struct page *page, int order)
         memcg_uncharge_kmem(memcg, PAGE_SIZE << order);
 }
 #else
-static inline void mem_cgroup_destroy_all_caches(struct mem_cgroup *memcg)
+static inline void memcg_unregister_all_caches(struct mem_cgroup *memcg)
 {
 }
 #endif /* CONFIG_MEMCG_KMEM */
@@ -6372,7 +6368,7 @@ static void mem_cgroup_css_offline(struct cgroup_subsys_state *css)
         css_for_each_descendant_post(iter, css)
                 mem_cgroup_reparent_charges(mem_cgroup_from_css(iter));
 
-        mem_cgroup_destroy_all_caches(memcg);
+        memcg_unregister_all_caches(memcg);
         vmpressure_cleanup(&memcg->vmpressure);
 }