leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

memcg: cleanup kmem cache creation/destruction functions naming

Browse Source 
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>
This commit is contained in:
Vladimir Davydov 2014-06-04 16:10:02 -07:00 committed by Linus Torvalds
parent 172cb4b3d4
commit 776ed0f037
4 changed files with 36 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/linux/memcontrol.h
View File

@ -505,7 +505,7 @@ __memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp);
int __memcg_charge_slab(struct kmem_cache *cachep, gfp_t gfp, int order);
void __memcg_uncharge_slab(struct kmem_cache *cachep, int order);
int __kmem_cache_destroy_memcg_children(struct kmem_cache *s);
int __memcg_cleanup_cache_params(struct kmem_cache *s);
/**
* memcg_kmem_newpage_charge: verify if a new kmem allocation is allowed.

2
include/linux/slab.h
View File

@ -116,7 +116,7 @@ struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
unsigned long,
void (*)(void *));
#ifdef CONFIG_MEMCG_KMEM
struct kmem_cache *kmem_cache_create_memcg(struct mem_cgroup *,
struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *,
struct kmem_cache *,
const char *);
#endif

60
mm/memcontrol.c
View File

@ -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);
}

12
mm/slab_common.c
View File

@ -261,7 +261,7 @@ EXPORT_SYMBOL(kmem_cache_create);
#ifdef CONFIG_MEMCG_KMEM
/*
* kmem_cache_create_memcg - Create a cache for a memory cgroup.
* memcg_create_kmem_cache - Create a cache for a memory cgroup.
* @memcg: The memory cgroup the new cache is for.
* @root_cache: The parent of the new cache.
* @memcg_name: The name of the memory cgroup (used for naming the new cache).
@ -270,7 +270,7 @@ EXPORT_SYMBOL(kmem_cache_create);
* requests going from @memcg to @root_cache. The new cache inherits properties
* from its parent.
*/
struct kmem_cache *kmem_cache_create_memcg(struct mem_cgroup *memcg,
struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *memcg,
struct kmem_cache *root_cache,
const char *memcg_name)
{
@ -305,7 +305,7 @@ out_unlock:
return s;
}
static int kmem_cache_destroy_memcg_children(struct kmem_cache *s)
static int memcg_cleanup_cache_params(struct kmem_cache *s)
{
int rc;
@ -314,13 +314,13 @@ static int kmem_cache_destroy_memcg_children(struct kmem_cache *s)
return 0;
mutex_unlock(&slab_mutex);
rc = __kmem_cache_destroy_memcg_children(s);
rc = __memcg_cleanup_cache_params(s);
mutex_lock(&slab_mutex);
return rc;
}
#else
static int kmem_cache_destroy_memcg_children(struct kmem_cache *s)
static int memcg_cleanup_cache_params(struct kmem_cache *s)
{
return 0;
}
@ -343,7 +343,7 @@ void kmem_cache_destroy(struct kmem_cache *s)
if (s->refcount)
goto out_unlock;
if (kmem_cache_destroy_memcg_children(s) != 0)
if (memcg_cleanup_cache_params(s) != 0)
goto out_unlock;
list_del(&s->list);