mm/slab.c: cleanup outdated comments and unify variables naming

 * OTOH the cpuarrays can contain lots of objects,

 * which could lock up otherwise freeable slabs.

 */

#define REAPTIMEOUT_CPUC	(2*HZ)

#define REAPTIMEOUT_LIST3	(4*HZ)

#define REAPTIMEOUT_AC		(2*HZ)

#define REAPTIMEOUT_NODE	(4*HZ)

#if STATS

#define	STATS_INC_ACTIVE(x)	((x)->num_active++)

	list_for_each_entry(cachep, &slab_caches, list) {

		/*

		 * Set up the size64 kmemlist for cpu before we can

		 * Set up the kmem_cache_node for cpu before we can

		 * begin anything. Make sure some other cpu on this

		 * node has not already allocated this

		 */

			if (!n)

				return -ENOMEM;

			kmem_cache_node_init(n);

			n->next_reap = jiffies + REAPTIMEOUT_LIST3 +

			    ((unsigned long)cachep) % REAPTIMEOUT_LIST3;

			n->next_reap = jiffies + REAPTIMEOUT_NODE +

			    ((unsigned long)cachep) % REAPTIMEOUT_NODE;

			/*

			 * The l3s don't come and go as CPUs come and

			 * go.  slab_mutex is sufficient

			 * The kmem_cache_nodes don't come and go as CPUs

			 * come and go.  slab_mutex is sufficient

			 * protection here.

			 */

			cachep->node[node] = n;

	for_each_online_node(node) {

		cachep->node[node] = &init_kmem_cache_node[index + node];

		cachep->node[node]->next_reap = jiffies +

		    REAPTIMEOUT_LIST3 +

		    ((unsigned long)cachep) % REAPTIMEOUT_LIST3;

		    REAPTIMEOUT_NODE +

		    ((unsigned long)cachep) % REAPTIMEOUT_NODE;

	}

}

		}

	}

	cachep->node[numa_mem_id()]->next_reap =

			jiffies + REAPTIMEOUT_LIST3 +

			((unsigned long)cachep) % REAPTIMEOUT_LIST3;

			jiffies + REAPTIMEOUT_NODE +

			((unsigned long)cachep) % REAPTIMEOUT_NODE;

	cpu_cache_get(cachep)->avail = 0;

	cpu_cache_get(cachep)->limit = BOOT_CPUCACHE_ENTRIES;

	if (flags & CFLGS_OFF_SLAB) {

		cachep->freelist_cache = kmalloc_slab(freelist_size, 0u);

		/*

		 * This is a possibility for one of the malloc_sizes caches.

		 * This is a possibility for one of the kmalloc_{dma,}_caches.

		 * But since we go off slab only for object size greater than

		 * PAGE_SIZE/8, and malloc_sizes gets created in ascending order,

		 * this should not happen at all.

		 * PAGE_SIZE/8, and kmalloc_{dma,}_caches get created

		 * in ascending order,this should not happen at all.

		 * But leave a BUG_ON for some lucky dude.

		 */

		BUG_ON(ZERO_OR_NULL_PTR(cachep->freelist_cache));

/*

 * Get the memory for a slab management obj.

 * For a slab cache when the slab descriptor is off-slab, slab descriptors

 * always come from malloc_sizes caches.  The slab descriptor cannot

 * come from the same cache which is getting created because,

 * when we are searching for an appropriate cache for these

 * descriptors in kmem_cache_create, we search through the malloc_sizes array.

 * If we are creating a malloc_sizes cache here it would not be visible to

 * kmem_find_general_cachep till the initialization is complete.

 * Hence we cannot have freelist_cache same as the original cache.

 *

 * For a slab cache when the slab descriptor is off-slab, the

 * slab descriptor can't come from the same cache which is being created,

 * Because if it is the case, that means we defer the creation of

 * the kmalloc_{dma,}_cache of size sizeof(slab descriptor) to this point.

 * And we eventually call down to __kmem_cache_create(), which

 * in turn looks up in the kmalloc_{dma,}_caches for the disired-size one.

 * This is a "chicken-and-egg" problem.

 *

 * So the off-slab slab descriptor shall come from the kmalloc_{dma,}_caches,

 * which are all initialized during kmem_cache_init().

 */

static void *alloc_slabmgmt(struct kmem_cache *cachep,

				   struct page *page, int colour_off,

}

/*

 * Caller needs to acquire correct kmem_list's list_lock

 * Caller needs to acquire correct kmem_cache_node's list_lock

 */

static void free_block(struct kmem_cache *cachep, void **objpp, int nr_objects,

		       int node)

	struct kmem_cache *cachep;

	void *ret;

	/* If you want to save a few bytes .text space: replace

	 * __ with kmem_.

	 * Then kmalloc uses the uninlined functions instead of the inline

	 * functions.

	 */

	cachep = kmalloc_slab(size, flags);

	if (unlikely(ZERO_OR_NULL_PTR(cachep)))

		return cachep;

/*

 * This initializes kmem_cache_node or resizes various caches for all nodes.

 */

static int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)

static int alloc_kmem_cache_node(struct kmem_cache *cachep, gfp_t gfp)

{

	int node;

	struct kmem_cache_node *n;

		}

		kmem_cache_node_init(n);

		n->next_reap = jiffies + REAPTIMEOUT_LIST3 +

				((unsigned long)cachep) % REAPTIMEOUT_LIST3;

		n->next_reap = jiffies + REAPTIMEOUT_NODE +

				((unsigned long)cachep) % REAPTIMEOUT_NODE;

		n->shared = new_shared;

		n->alien = new_alien;

		n->free_limit = (1 + nr_cpus_node(node)) *

		kfree(ccold);

	}

	kfree(new);

	return alloc_kmemlist(cachep, gfp);

	return alloc_kmem_cache_node(cachep, gfp);

}

static int do_tune_cpucache(struct kmem_cache *cachep, int limit,

		if (time_after(n->next_reap, jiffies))

			goto next;

		n->next_reap = jiffies + REAPTIMEOUT_LIST3;

		n->next_reap = jiffies + REAPTIMEOUT_NODE;

		drain_array(searchp, n, n->shared, 0, node);

	next_reap_node();

out:

	/* Set up the next iteration */

	schedule_delayed_work(work, round_jiffies_relative(REAPTIMEOUT_CPUC));

	schedule_delayed_work(work, round_jiffies_relative(REAPTIMEOUT_AC));

}

#ifdef CONFIG_SLABINFO