memcg: get rid of kmem_cache_dup()

	schedule_work(&cachep->memcg_params->destroy);

}

/*

 * This lock protects updaters, not readers. We want readers to be as fast as

 * they can, and they will either see NULL or a valid cache value. Our model

 * allow them to see NULL, in which case the root memcg will be selected.

 *

 * We need this lock because multiple allocations to the same cache from a non

 * will span more than one worker. Only one of them can create the cache.

 */

static DEFINE_MUTEX(memcg_cache_mutex);

/*

 * Called with memcg_cache_mutex held

 */

static struct kmem_cache *kmem_cache_dup(struct mem_cgroup *memcg,

static struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *memcg,

						  struct kmem_cache *s)

{

	struct kmem_cache *new;

	static char *tmp_name = NULL;

	static DEFINE_MUTEX(mutex);	/* protects tmp_name */

	lockdep_assert_held(&memcg_cache_mutex);

	BUG_ON(!memcg_can_account_kmem(memcg));

	mutex_lock(&mutex);

	/*

	 * kmem_cache_create_memcg duplicates the given name and

	 * cgroup_name for this name requires RCU context.

	if (new)

		new->allocflags |= __GFP_KMEMCG;

	else

		new = s;

	mutex_unlock(&mutex);

	return new;

}

static struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *memcg,

						  struct kmem_cache *cachep)

{

	struct kmem_cache *new_cachep;

	BUG_ON(!memcg_can_account_kmem(memcg));

	mutex_lock(&memcg_cache_mutex);

	new_cachep = kmem_cache_dup(memcg, cachep);

	if (new_cachep == NULL)

		new_cachep = cachep;

	mutex_unlock(&memcg_cache_mutex);

	return new_cachep;

}

void kmem_cache_destroy_memcg_children(struct kmem_cache *s)

{

	struct kmem_cache *c;