Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f527cf40 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'slab-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/christoph/vm 

* 'slab-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/christoph/vm:
  slub: Support 4k kmallocs again to compensate for page allocator slowness
  slub: Fallback to kmalloc_large for failing higher order allocs
  slub: Determine gfpflags once and not every time a slab is allocated
  make slub.c:slab_address() static
  slub: kmalloc page allocator pass-through cleanup
  slab: avoid double initialization & do initialization in 1 place
parents cead99dc 331dc558

include/linux/slub_def.h

+10 −5
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ struct kmem_cache { 


	/* Allocation and freeing of slabs */

	int objects;		/* Number of objects in slab */

	gfp_t allocflags;	/* gfp flags to use on each alloc */

	int refcount;		/* Refcount for slab cache destroy */

	void (*ctor)(struct kmem_cache *, void *);

	int inuse;		/* Offset to metadata */
@@ -110,7 +111,7 @@ struct kmem_cache { 
 * We keep the general caches in an array of slab caches that are used for

 * 2^x bytes of allocations.

 */

extern struct kmem_cache kmalloc_caches[PAGE_SHIFT];

extern struct kmem_cache kmalloc_caches[PAGE_SHIFT + 1];



/*

 * Sorry that the following has to be that ugly but some versions of GCC
@@ -188,12 +189,16 @@ static __always_inline struct kmem_cache *kmalloc_slab(size_t size) 
void *kmem_cache_alloc(struct kmem_cache *, gfp_t);

void *__kmalloc(size_t size, gfp_t flags);



static __always_inline void *kmalloc_large(size_t size, gfp_t flags)

{

	return (void *)__get_free_pages(flags | __GFP_COMP, get_order(size));

}



static __always_inline void *kmalloc(size_t size, gfp_t flags)

{

	if (__builtin_constant_p(size)) {

		if (size > PAGE_SIZE / 2)

			return (void *)__get_free_pages(flags | __GFP_COMP,

							get_order(size));

		if (size > PAGE_SIZE)

			return kmalloc_large(size, flags);



		if (!(flags & SLUB_DMA)) {

			struct kmem_cache *s = kmalloc_slab(size);
@@ -214,7 +219,7 @@ void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node); 
static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)

{

	if (__builtin_constant_p(size) &&

		size <= PAGE_SIZE / 2 && !(flags & SLUB_DMA)) {

		size <= PAGE_SIZE && !(flags & SLUB_DMA)) {

			struct kmem_cache *s = kmalloc_slab(size);



		if (!s)

mm/slab.c

+1 −2
Original line number Diff line number Diff line
@@ -2630,6 +2630,7 @@ static struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp, 
	slabp->colouroff = colour_off;

	slabp->s_mem = objp + colour_off;

	slabp->nodeid = nodeid;

	slabp->free = 0;

	return slabp;

}
@@ -2683,7 +2684,6 @@ static void cache_init_objs(struct kmem_cache *cachep, 
		slab_bufctl(slabp)[i] = i + 1;

	}

	slab_bufctl(slabp)[i - 1] = BUFCTL_END;

	slabp->free = 0;

}



static void kmem_flagcheck(struct kmem_cache *cachep, gfp_t flags)
@@ -2816,7 +2816,6 @@ static int cache_grow(struct kmem_cache *cachep, 
	if (!slabp)

		goto opps1;



	slabp->nodeid = nodeid;

	slab_map_pages(cachep, slabp, objp);



	cache_init_objs(cachep, slabp);

mm/slub.c

+64 −30
Original line number Diff line number Diff line
@@ -211,6 +211,8 @@ static inline void ClearSlabDebug(struct page *page) 
/* Internal SLUB flags */

#define __OBJECT_POISON		0x80000000 /* Poison object */

#define __SYSFS_ADD_DEFERRED	0x40000000 /* Not yet visible via sysfs */

#define __KMALLOC_CACHE		0x20000000 /* objects freed using kfree */

#define __PAGE_ALLOC_FALLBACK	0x10000000 /* Allow fallback to page alloc */



/* Not all arches define cache_line_size */

#ifndef cache_line_size
@@ -308,7 +310,7 @@ static inline int is_end(void *addr) 
	return (unsigned long)addr & PAGE_MAPPING_ANON;

}



void *slab_address(struct page *page)

static void *slab_address(struct page *page)

{

	return page->end - PAGE_MAPPING_ANON;

}
@@ -1078,14 +1080,7 @@ static struct page *allocate_slab(struct kmem_cache *s, gfp_t flags, int node) 
	struct page *page;

	int pages = 1 << s->order;



	if (s->order)

		flags |= __GFP_COMP;



	if (s->flags & SLAB_CACHE_DMA)

		flags |= SLUB_DMA;



	if (s->flags & SLAB_RECLAIM_ACCOUNT)

		flags |= __GFP_RECLAIMABLE;

	flags |= s->allocflags;



	if (node == -1)

		page = alloc_pages(flags, s->order);
@@ -1546,7 +1541,6 @@ static void *__slab_alloc(struct kmem_cache *s, 
unlock_out:

	slab_unlock(c->page);

	stat(c, ALLOC_SLOWPATH);

out:

#ifdef SLUB_FASTPATH

	local_irq_restore(flags);

#endif
@@ -1581,8 +1575,24 @@ static void *__slab_alloc(struct kmem_cache *s, 
		c->page = new;

		goto load_freelist;

	}

	object = NULL;

	goto out;

#ifdef SLUB_FASTPATH

	local_irq_restore(flags);

#endif

	/*

	 * No memory available.

	 *

	 * If the slab uses higher order allocs but the object is

	 * smaller than a page size then we can fallback in emergencies

	 * to the page allocator via kmalloc_large. The page allocator may

	 * have failed to obtain a higher order page and we can try to

	 * allocate a single page if the object fits into a single page.

	 * That is only possible if certain conditions are met that are being

	 * checked when a slab is created.

	 */

	if (!(gfpflags & __GFP_NORETRY) && (s->flags & __PAGE_ALLOC_FALLBACK))

		return kmalloc_large(s->objsize, gfpflags);



	return NULL;

debug:

	object = c->page->freelist;

	if (!alloc_debug_processing(s, c->page, object, addr))
@@ -2329,10 +2339,33 @@ static int calculate_sizes(struct kmem_cache *s) 
	size = ALIGN(size, align);

	s->size = size;



	if ((flags & __KMALLOC_CACHE) &&

			PAGE_SIZE / size < slub_min_objects) {

		/*

		 * Kmalloc cache that would not have enough objects in

		 * an order 0 page. Kmalloc slabs can fallback to

		 * page allocator order 0 allocs so take a reasonably large

		 * order that will allows us a good number of objects.

		 */

		s->order = max(slub_max_order, PAGE_ALLOC_COSTLY_ORDER);

		s->flags |= __PAGE_ALLOC_FALLBACK;

		s->allocflags |= __GFP_NOWARN;

	} else

		s->order = calculate_order(size);



	if (s->order < 0)

		return 0;



	s->allocflags = 0;

	if (s->order)

		s->allocflags |= __GFP_COMP;



	if (s->flags & SLAB_CACHE_DMA)

		s->allocflags |= SLUB_DMA;



	if (s->flags & SLAB_RECLAIM_ACCOUNT)

		s->allocflags |= __GFP_RECLAIMABLE;



	/*

	 * Determine the number of objects per slab

	 */
@@ -2484,11 +2517,11 @@ EXPORT_SYMBOL(kmem_cache_destroy); 
 *		Kmalloc subsystem

 *******************************************************************/



struct kmem_cache kmalloc_caches[PAGE_SHIFT] __cacheline_aligned;

struct kmem_cache kmalloc_caches[PAGE_SHIFT + 1] __cacheline_aligned;

EXPORT_SYMBOL(kmalloc_caches);



#ifdef CONFIG_ZONE_DMA

static struct kmem_cache *kmalloc_caches_dma[PAGE_SHIFT];

static struct kmem_cache *kmalloc_caches_dma[PAGE_SHIFT + 1];

#endif



static int __init setup_slub_min_order(char *str)
@@ -2536,7 +2569,7 @@ static struct kmem_cache *create_kmalloc_cache(struct kmem_cache *s, 


	down_write(&slub_lock);

	if (!kmem_cache_open(s, gfp_flags, name, size, ARCH_KMALLOC_MINALIGN,

			flags, NULL))

			flags | __KMALLOC_CACHE, NULL))

		goto panic;



	list_add(&s->list, &slab_caches);
@@ -2670,9 +2703,8 @@ void *__kmalloc(size_t size, gfp_t flags) 
{

	struct kmem_cache *s;



	if (unlikely(size > PAGE_SIZE / 2))

		return (void *)__get_free_pages(flags | __GFP_COMP,

							get_order(size));

	if (unlikely(size > PAGE_SIZE))

		return kmalloc_large(size, flags);



	s = get_slab(size, flags);
@@ -2688,9 +2720,8 @@ void *__kmalloc_node(size_t size, gfp_t flags, int node) 
{

	struct kmem_cache *s;



	if (unlikely(size > PAGE_SIZE / 2))

		return (void *)__get_free_pages(flags | __GFP_COMP,

							get_order(size));

	if (unlikely(size > PAGE_SIZE))

		return kmalloc_large(size, flags);



	s = get_slab(size, flags);
@@ -3001,7 +3032,7 @@ void __init kmem_cache_init(void) 
		caches++;

	}



	for (i = KMALLOC_SHIFT_LOW; i < PAGE_SHIFT; i++) {

	for (i = KMALLOC_SHIFT_LOW; i <= PAGE_SHIFT; i++) {

		create_kmalloc_cache(&kmalloc_caches[i],

			"kmalloc", 1 << i, GFP_KERNEL);

		caches++;
@@ -3028,7 +3059,7 @@ void __init kmem_cache_init(void) 
	slab_state = UP;



	/* Provide the correct kmalloc names now that the caches are up */

	for (i = KMALLOC_SHIFT_LOW; i < PAGE_SHIFT; i++)

	for (i = KMALLOC_SHIFT_LOW; i <= PAGE_SHIFT; i++)

		kmalloc_caches[i]. name =

			kasprintf(GFP_KERNEL, "kmalloc-%d", 1 << i);
@@ -3057,6 +3088,9 @@ static int slab_unmergeable(struct kmem_cache *s) 
	if (slub_nomerge || (s->flags & SLUB_NEVER_MERGE))

		return 1;



	if ((s->flags & __PAGE_ALLOC_FALLBACK))

		return 1;



	if (s->ctor)

		return 1;
@@ -3218,9 +3252,9 @@ void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, void *caller) 
{

	struct kmem_cache *s;



	if (unlikely(size > PAGE_SIZE / 2))

		return (void *)__get_free_pages(gfpflags | __GFP_COMP,

							get_order(size));

	if (unlikely(size > PAGE_SIZE))

		return kmalloc_large(size, gfpflags);



	s = get_slab(size, gfpflags);



	if (unlikely(ZERO_OR_NULL_PTR(s)))
@@ -3234,9 +3268,9 @@ void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags, 
{

	struct kmem_cache *s;



	if (unlikely(size > PAGE_SIZE / 2))

		return (void *)__get_free_pages(gfpflags | __GFP_COMP,

							get_order(size));

	if (unlikely(size > PAGE_SIZE))

		return kmalloc_large(size, gfpflags);



	s = get_slab(size, gfpflags);



	if (unlikely(ZERO_OR_NULL_PTR(s)))