Enable using kmalloc_index() in allocator test modules again where the size may be non-constant, while ensuring normal usage always passes a constant size. Split the definition into __kmalloc_index(size, size_is_constant), and a definition of kmalloc_index(s), matching the old kmalloc_index() interface, but that still requires size_is_constant==true. This ensures that normal usage of kmalloc_index() always passes a constant size. While the __-prefix should make it clearer that the function is to be used with care, also rewrite the "Note" to highlight the restriction (and add a hint to kmalloc_slab()). The alternative considered here is to export kmalloc_slab(), but given it is internal to mm/ and not in <linux/slab.h>, we should probably avoid exporting it. Allocator test modules will work just fine by using __kmalloc_index(s, false). Link: https://lkml.kernel.org/r/20210512195227.245000695c9014242e9a00e5@xxxxxxxxxxxxxxxxxxxx Signed-off-by: Marco Elver <elver@xxxxxxxxxx> --- include/linux/slab.h | 15 +++++++++++---- mm/kfence/kfence_test.c | 5 +++-- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/include/linux/slab.h b/include/linux/slab.h index 27d142564557..465c5d9d9630 100644 --- a/include/linux/slab.h +++ b/include/linux/slab.h @@ -347,10 +347,13 @@ static __always_inline enum kmalloc_cache_type kmalloc_type(gfp_t flags) * 2 = 129 .. 192 bytes * n = 2^(n-1)+1 .. 2^n * - * Note: there's no need to optimize kmalloc_index because it's evaluated - * in compile-time. + * Note: __kmalloc_index() is compile-time optimized, and not runtime optimized; + * typical usage is via kmalloc_index() and therefore evaluated at compile-time. + * Callers where !size_is_constant should only be test modules, where runtime + * overheads of __kmalloc_index() can be tolerated. Also see kmalloc_slab(). */ -static __always_inline unsigned int kmalloc_index(size_t size) +static __always_inline unsigned int __kmalloc_index(size_t size, + bool size_is_constant) { if (!size) return 0; @@ -386,11 +389,15 @@ static __always_inline unsigned int kmalloc_index(size_t size) if (size <= 16 * 1024 * 1024) return 24; if (size <= 32 * 1024 * 1024) return 25; - BUILD_BUG_ON_MSG(1, "unexpected size in kmalloc_index()"); + if (size_is_constant) + BUILD_BUG_ON_MSG(1, "unexpected size in kmalloc_index()"); + else + BUG(); /* Will never be reached. Needed because the compiler may complain */ return -1; } +#define kmalloc_index(s) __kmalloc_index(s, true) #endif /* !CONFIG_SLOB */ void *__kmalloc(size_t size, gfp_t flags) __assume_kmalloc_alignment __malloc; diff --git a/mm/kfence/kfence_test.c b/mm/kfence/kfence_test.c index 4acf4251ee04..7f24b9bcb2ec 100644 --- a/mm/kfence/kfence_test.c +++ b/mm/kfence/kfence_test.c @@ -197,7 +197,7 @@ static void test_cache_destroy(void) static inline size_t kmalloc_cache_alignment(size_t size) { - return kmalloc_caches[kmalloc_type(GFP_KERNEL)][kmalloc_index(size)]->align; + return kmalloc_caches[kmalloc_type(GFP_KERNEL)][__kmalloc_index(size, false)]->align; } /* Must always inline to match stack trace against caller. */ @@ -267,7 +267,8 @@ static void *test_alloc(struct kunit *test, size_t size, gfp_t gfp, enum allocat if (is_kfence_address(alloc)) { struct page *page = virt_to_head_page(alloc); - struct kmem_cache *s = test_cache ?: kmalloc_caches[kmalloc_type(GFP_KERNEL)][kmalloc_index(size)]; + struct kmem_cache *s = test_cache ?: + kmalloc_caches[kmalloc_type(GFP_KERNEL)][__kmalloc_index(size, false)]; /* * Verify that various helpers return the right values -- 2.31.1.607.g51e8a6a459-goog
