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

Commit ae97b196 authored by Vlastimil Babka's avatar Vlastimil Babka Committed by Suren Baghdasaryan
Browse files

UPSTREAM: mm, slab/slub: introduce kmalloc-reclaimable caches 

Kmem caches can be created with a SLAB_RECLAIM_ACCOUNT flag, which
indicates they contain objects which can be reclaimed under memory
pressure (typically through a shrinker).  This makes the slab pages
accounted as NR_SLAB_RECLAIMABLE in vmstat, which is reflected also the
MemAvailable meminfo counter and in overcommit decisions.  The slab pages
are also allocated with __GFP_RECLAIMABLE, which is good for
anti-fragmentation through grouping pages by mobility.

The generic kmalloc-X caches are created without this flag, but sometimes
are used also for objects that can be reclaimed, which due to varying size
cannot have a dedicated kmem cache with SLAB_RECLAIM_ACCOUNT flag.  A
prominent example are dcache external names, which prompted the creation
of a new, manually managed vmstat counter NR_INDIRECTLY_RECLAIMABLE_BYTES
in commit f1782c9b ("dcache: account external names as indirectly
reclaimable memory").

To better handle this and any other similar cases, this patch introduces
SLAB_RECLAIM_ACCOUNT variants of kmalloc caches, named kmalloc-rcl-X.
They are used whenever the kmalloc() call passes __GFP_RECLAIMABLE among
gfp flags.  They are added to the kmalloc_caches array as a new type.
Allocations with both __GFP_DMA and __GFP_RECLAIMABLE will use a dma type
cache.

This change only applies to SLAB and SLUB, not SLOB.  This is fine, since
SLOB's target are tiny system and this patch does add some overhead of
kmem management objects.

Link: http://lkml.kernel.org/r/20180731090649.16028-3-vbabka@suse.cz


Signed-off-by: default avatarVlastimil Babka <vbabka@suse.cz>
Acked-by: default avatarMel Gorman <mgorman@techsingularity.net>
Acked-by: default avatarChristoph Lameter <cl@linux.com>
Acked-by: default avatarRoman Gushchin <guro@fb.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Laura Abbott <labbott@redhat.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Sumit Semwal <sumit.semwal@linaro.org>
Cc: Vijayanand Jitta <vjitta@codeaurora.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>

(cherry picked from commit 1291523f2c1d631fea34102fd241fb54a4e8f7a0)

Bug: 138148041
Test: verify KReclaimable accounting after ION allocation+deallocation
Change-Id: Ifd4fa79c0b1f27606f91f2f2b2e92464664ab021
Signed-off-by: default avatarSuren Baghdasaryan <surenb@google.com>
parent 9d8edd92

include/linux/slab.h

+15 −1
Original line number Diff line number Diff line
@@ -297,8 +297,13 @@ static inline void __check_heap_object(const void *ptr, unsigned long n, 
#define SLAB_OBJ_MIN_SIZE      (KMALLOC_MIN_SIZE < 16 ? \

                               (KMALLOC_MIN_SIZE) : 16)



/*

 * Whenever changing this, take care of that kmalloc_type() and

 * create_kmalloc_caches() still work as intended.

 */

enum kmalloc_cache_type {

	KMALLOC_NORMAL = 0,

	KMALLOC_RECLAIM,

#ifdef CONFIG_ZONE_DMA

	KMALLOC_DMA,

#endif
@@ -312,12 +317,21 @@ kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1]; 
static __always_inline enum kmalloc_cache_type kmalloc_type(gfp_t flags)

{

	int is_dma = 0;

	int type_dma = 0;

	int is_reclaimable;



#ifdef CONFIG_ZONE_DMA

	is_dma = !!(flags & __GFP_DMA);

	type_dma = is_dma * KMALLOC_DMA;

#endif



	return is_dma;

	is_reclaimable = !!(flags & __GFP_RECLAIMABLE);



	/*

	 * If an allocation is both __GFP_DMA and __GFP_RECLAIMABLE, return

	 * KMALLOC_DMA and effectively ignore __GFP_RECLAIMABLE

	 */

	return type_dma + (is_reclaimable & !is_dma) * KMALLOC_RECLAIM;

}



/*

mm/slab_common.c

+31 −17
Original line number Diff line number Diff line
@@ -1108,10 +1108,21 @@ void __init setup_kmalloc_cache_index_table(void) 
	}

}



static void __init new_kmalloc_cache(int idx, slab_flags_t flags)

static void __init

new_kmalloc_cache(int idx, int type, slab_flags_t flags)

{

	kmalloc_caches[KMALLOC_NORMAL][idx] = create_kmalloc_cache(

					kmalloc_info[idx].name,

	const char *name;



	if (type == KMALLOC_RECLAIM) {

		flags |= SLAB_RECLAIM_ACCOUNT;

		name = kasprintf(GFP_NOWAIT, "kmalloc-rcl-%u",

						kmalloc_info[idx].size);

		BUG_ON(!name);

	} else {

		name = kmalloc_info[idx].name;

	}



	kmalloc_caches[type][idx] = create_kmalloc_cache(name,

					kmalloc_info[idx].size, flags, 0,

					kmalloc_info[idx].size);

}
@@ -1123,22 +1134,25 @@ static void __init new_kmalloc_cache(int idx, slab_flags_t flags) 
 */

void __init create_kmalloc_caches(slab_flags_t flags)

{

	int i;

	int type = KMALLOC_NORMAL;

	int i, type;



	for (type = KMALLOC_NORMAL; type <= KMALLOC_RECLAIM; type++) {

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

			if (!kmalloc_caches[type][i])

			new_kmalloc_cache(i, flags);

				new_kmalloc_cache(i, type, flags);



			/*

			 * Caches that are not of the two-to-the-power-of size.

			 * These have to be created immediately after the

			 * earlier power of two caches

			 */

		if (KMALLOC_MIN_SIZE <= 32 && !kmalloc_caches[type][1] && i == 6)

			new_kmalloc_cache(1, flags);

		if (KMALLOC_MIN_SIZE <= 64 && !kmalloc_caches[type][2] && i == 7)

			new_kmalloc_cache(2, flags);

			if (KMALLOC_MIN_SIZE <= 32 && i == 6 &&

					!kmalloc_caches[type][1])

				new_kmalloc_cache(1, type, flags);

			if (KMALLOC_MIN_SIZE <= 64 && i == 7 &&

					!kmalloc_caches[type][2])

				new_kmalloc_cache(2, type, flags);

		}

	}



	/* Kmalloc array is now usable */