Commit 8339f7d8 authored by Mark Rutland's avatar Mark Rutland Committed by Catalin Marinas
Browse files

arm64: module: remove old !KASAN_VMALLOC logic 



Historically, KASAN could be selected with or without KASAN_VMALLOC, and
we had to be very careful where to place modules when KASAN_VMALLOC was
not selected.

However, since commit:

  f6f37d93 ("arm64: select KASAN_VMALLOC for SW/HW_TAGS modes")

Selecting CONFIG_KASAN on arm64 will also select CONFIG_KASAN_VMALLOC,
and so the logic for handling CONFIG_KASAN without CONFIG_KASAN_VMALLOC
is redundant and can be removed.

Note: the "kasan.vmalloc={on,off}" option which only exists for HW_TAGS
changes whether the vmalloc region is given non-match-all tags, and does
not affect the page table manipulation code.

The VM_DEFER_KMEMLEAK flag was only necessary for !CONFIG_KASAN_VMALLOC
as described in its introduction in commit:

  60115fa5 ("mm: defer kmemleak object creation of module_alloc()")

... and therefore it can also be removed.

Remove the redundant logic for !CONFIG_KASAN_VMALLOC. At the same time,
add the missing braces around the multi-line conditional block in
arch/arm64/kernel/module.c.

Suggested-by: default avatarArd Biesheuvel <ardb@kernel.org>
Signed-off-by: default avatarMark Rutland <mark.rutland@arm.com>
Reviewed-by: default avatarArd Biesheuvel <ardb@kernel.org>
Cc: Alexander Potapenko <glider@google.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andrey Konovalov <andreyknvl@google.com>
Cc: Andrey Ryabinin <ryabinin.a.a@gmail.com>
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Will Deacon <will@kernel.org>
Tested-by: default avatarShanker Donthineni <sdonthineni@nvidia.com>
Link: https://lore.kernel.org/r/20230530110328.2213762-2-mark.rutland@arm.com


Signed-off-by: default avatarCatalin Marinas <catalin.marinas@arm.com>
parent 44c026a7

arch/arm64/kernel/kaslr.c

+0 −10
Original line number Diff line number Diff line
@@ -48,16 +48,6 @@ static int __init kaslr_init(void) 


	pr_info("KASLR enabled\n");



	/*

	 * KASAN without KASAN_VMALLOC does not expect the module region to

	 * intersect the vmalloc region, since shadow memory is allocated for

	 * each module at load time, whereas the vmalloc region will already be

	 * shadowed by KASAN zero pages.

	 */

	BUILD_BUG_ON((IS_ENABLED(CONFIG_KASAN_GENERIC) ||

	              IS_ENABLED(CONFIG_KASAN_SW_TAGS)) &&

		     !IS_ENABLED(CONFIG_KASAN_VMALLOC));



	seed = get_random_u32();



	if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) {

arch/arm64/kernel/module.c

+3 −20
Original line number Diff line number Diff line
@@ -32,33 +32,16 @@ void *module_alloc(unsigned long size) 
	if (IS_ENABLED(CONFIG_ARM64_MODULE_PLTS))

		gfp_mask |= __GFP_NOWARN;



	if (IS_ENABLED(CONFIG_KASAN_GENERIC) ||

	    IS_ENABLED(CONFIG_KASAN_SW_TAGS))

		/* don't exceed the static module region - see below */

		module_alloc_end = MODULES_END;



	p = __vmalloc_node_range(size, MODULE_ALIGN, module_alloc_base,

				module_alloc_end, gfp_mask, PAGE_KERNEL, VM_DEFER_KMEMLEAK,

				module_alloc_end, gfp_mask, PAGE_KERNEL, 0,

				NUMA_NO_NODE, __builtin_return_address(0));



	if (!p && IS_ENABLED(CONFIG_ARM64_MODULE_PLTS) &&

	    (IS_ENABLED(CONFIG_KASAN_VMALLOC) ||

	     (!IS_ENABLED(CONFIG_KASAN_GENERIC) &&

	      !IS_ENABLED(CONFIG_KASAN_SW_TAGS))))

		/*

		 * KASAN without KASAN_VMALLOC can only deal with module

		 * allocations being served from the reserved module region,

		 * since the remainder of the vmalloc region is already

		 * backed by zero shadow pages, and punching holes into it

		 * is non-trivial. Since the module region is not randomized

		 * when KASAN is enabled without KASAN_VMALLOC, it is even

		 * less likely that the module region gets exhausted, so we

		 * can simply omit this fallback in that case.

		 */

	if (!p && IS_ENABLED(CONFIG_ARM64_MODULE_PLTS)) {

		p = __vmalloc_node_range(size, MODULE_ALIGN, module_alloc_base,

				module_alloc_base + SZ_2G, GFP_KERNEL,

				PAGE_KERNEL, 0, NUMA_NO_NODE,

				__builtin_return_address(0));

	}



	if (p && (kasan_alloc_module_shadow(p, size, gfp_mask) < 0)) {

		vfree(p);