// SPDX-License-Identifier: GPL-2.0-or-later/* * Test cases for struct randomization, i.e. CONFIG_RANDSTRUCT=y. * * For example, see: * "Running tests with kunit_tool" at Documentation/dev-tools/kunit/start.rst *	./tools/testing/kunit/kunit.py run randstruct [--raw_output] \ *		[--make_option LLVM=1] \ *		--kconfig_add CONFIG_RANDSTRUCT_FULL=y * */#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <kunit/test.h>#include <linux/init.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/string.h> #define DO_MANY_MEMBERS(macro, args...)	\	macro(a, args)			\	macro(b, args)			\	macro(c, args)			\	macro(d, args)			\	macro(e, args)			\	macro(f, args)			\	macro(g, args)			\	macro(h, args) #define do_enum(x, ignored)	MEMBER_NAME_ ## x,enum randstruct_member_names {	DO_MANY_MEMBERS(do_enum)	MEMBER_NAME_MAX,};/* Make sure the macros are working: want 8 test members. */_Static_assert(MEMBER_NAME_MAX == 8, "Number of test members changed?!"); /* This is an unsigned long member to match the function pointer size */#define unsigned_long_member(x, ignored)	unsigned long x;struct randstruct_untouched {	DO_MANY_MEMBERS(unsigned_long_member)}; /* Struct explicitly marked with __randomize_layout. */struct randstruct_shuffled {	DO_MANY_MEMBERS(unsigned_long_member)} __randomize_layout;#undef unsigned_long_member /* Struct implicitly randomized from being all func ptrs. */#define func_member(x, ignored)	size_t (*x)(int);struct randstruct_funcs_untouched {	DO_MANY_MEMBERS(func_member)} __no_randomize_layout; struct randstruct_funcs_shuffled {	DO_MANY_MEMBERS(func_member)}; #define func_body(x, ignored)					\static noinline size_t func_##x(int arg)			\{								\	return offsetof(struct randstruct_funcs_untouched, x);	\}DO_MANY_MEMBERS(func_body) /* Various mixed types. */#define mixed_members					\	bool a;						\	short b;					\	unsigned int c __aligned(16);			\	size_t d;					\	char e;						\	u64 f;						\	union {						\		struct randstruct_shuffled shuffled;	\		uintptr_t g;				\	};						\	union {						\		void *ptr;				\		char h;					\	}; struct randstruct_mixed_untouched {	mixed_members}; struct randstruct_mixed_shuffled {	mixed_members} __randomize_layout;#undef mixed_members struct contains_randstruct_untouched {	int before;	struct randstruct_untouched untouched;	int after;}; struct contains_randstruct_shuffled {	int before;	struct randstruct_shuffled shuffled;	int after;}; struct contains_func_untouched {	struct randstruct_funcs_shuffled inner;	DO_MANY_MEMBERS(func_member)} __no_randomize_layout; struct contains_func_shuffled {	struct randstruct_funcs_shuffled inner;	DO_MANY_MEMBERS(func_member)};#undef func_member #define check_mismatch(x, untouched, shuffled)	\	if (offsetof(untouched, x) != offsetof(shuffled, x))	\		mismatches++;					\	kunit_info(test, #shuffled "::" #x " @ %zu (vs %zu)\n",	\		   offsetof(shuffled, x),			\		   offsetof(untouched, x));			\ #define check_pair(outcome, untouched, shuffled, checker...)	\	mismatches = 0;						\	DO_MANY_MEMBERS(checker, untouched, shuffled)	\	kunit_info(test, "Differing " #untouched " vs " #shuffled " member positions: %d\n", \		   mismatches);					\	KUNIT_##outcome##_MSG(test, mismatches, 0,		\			      #untouched " vs " #shuffled " layouts: unlucky or broken?\n"); static void randstruct_layout_same(struct kunit *test){	int mismatches; 	check_pair(EXPECT_EQ, struct randstruct_untouched, struct randstruct_untouched,		   check_mismatch)	check_pair(EXPECT_GT, struct randstruct_untouched, struct randstruct_shuffled,		   check_mismatch)} static void randstruct_layout_mixed(struct kunit *test){	int mismatches; 	check_pair(EXPECT_EQ, struct randstruct_mixed_untouched, struct randstruct_mixed_untouched,		   check_mismatch)	check_pair(EXPECT_GT, struct randstruct_mixed_untouched, struct randstruct_mixed_shuffled,		   check_mismatch)} static void randstruct_layout_fptr(struct kunit *test){	int mismatches; 	check_pair(EXPECT_EQ, struct randstruct_untouched, struct randstruct_untouched,		   check_mismatch)	check_pair(EXPECT_GT, struct randstruct_untouched, struct randstruct_funcs_shuffled,		   check_mismatch)	check_pair(EXPECT_GT, struct randstruct_funcs_untouched, struct randstruct_funcs_shuffled,		   check_mismatch)} #define check_mismatch_prefixed(x, prefix, untouched, shuffled)	\	check_mismatch(prefix.x, untouched, shuffled) static void randstruct_layout_fptr_deep(struct kunit *test){	int mismatches; 	if (IS_ENABLED(CONFIG_CC_IS_CLANG))		kunit_skip(test, "Clang randstruct misses inner functions: https://github.com/llvm/llvm-project/issues/138355"); 	check_pair(EXPECT_EQ, struct contains_func_untouched, struct contains_func_untouched,			check_mismatch_prefixed, inner) 	check_pair(EXPECT_GT, struct contains_func_untouched, struct contains_func_shuffled,			check_mismatch_prefixed, inner)} #undef check_pair#undef check_mismatch #define check_mismatch(x, ignore)				\	KUNIT_EXPECT_EQ_MSG(test, untouched->x, shuffled->x,	\			    "Mismatched member value in %s initializer\n", \			    name); static void test_check_init(struct kunit *test, const char *name,			    struct randstruct_untouched *untouched,			    struct randstruct_shuffled *shuffled){	DO_MANY_MEMBERS(check_mismatch)} static void test_check_mixed_init(struct kunit *test, const char *name,				  struct randstruct_mixed_untouched *untouched,				  struct randstruct_mixed_shuffled *shuffled){	DO_MANY_MEMBERS(check_mismatch)}#undef check_mismatch #define check_mismatch(x, ignore)				\	KUNIT_EXPECT_EQ_MSG(test, untouched->untouched.x,	\			    shuffled->shuffled.x,		\			    "Mismatched member value in %s initializer\n", \			    name);static void test_check_contained_init(struct kunit *test, const char *name,				      struct contains_randstruct_untouched *untouched,				      struct contains_randstruct_shuffled *shuffled){	DO_MANY_MEMBERS(check_mismatch)}#undef check_mismatch #define check_mismatch(x, ignore)					\	KUNIT_EXPECT_PTR_EQ_MSG(test, untouched->x, shuffled->x,	\			    "Mismatched member value in %s initializer\n", \			    name); static void test_check_funcs_init(struct kunit *test, const char *name,				  struct randstruct_funcs_untouched *untouched,				  struct randstruct_funcs_shuffled *shuffled){	DO_MANY_MEMBERS(check_mismatch)}#undef check_mismatch static void randstruct_initializers(struct kunit *test){#define init_members		\		.a = 1,		\		.b = 3,		\		.c = 5,		\		.d = 7,		\		.e = 11,	\		.f = 13,	\		.g = 17,	\		.h = 19,	struct randstruct_untouched untouched = {		init_members	};	struct randstruct_shuffled shuffled = {		init_members	};	struct randstruct_mixed_untouched mixed_untouched = {		init_members	};	struct randstruct_mixed_shuffled mixed_shuffled = {		init_members	};	struct contains_randstruct_untouched contains_untouched = {		.untouched = {			init_members		},	};	struct contains_randstruct_shuffled contains_shuffled = {		.shuffled = {			init_members		},	};#define func_member(x, ignored)	\		.x = func_##x,	struct randstruct_funcs_untouched funcs_untouched = {		DO_MANY_MEMBERS(func_member)	};	struct randstruct_funcs_shuffled funcs_shuffled = {		DO_MANY_MEMBERS(func_member)	}; 	test_check_init(test, "named", &untouched, &shuffled);	test_check_init(test, "unnamed", &untouched,		&(struct randstruct_shuffled){			init_members		}); 	test_check_contained_init(test, "named", &contains_untouched, &contains_shuffled);	test_check_contained_init(test, "unnamed", &contains_untouched,		&(struct contains_randstruct_shuffled){			.shuffled = (struct randstruct_shuffled){				init_members			},		}); 	test_check_contained_init(test, "named", &contains_untouched, &contains_shuffled);	test_check_contained_init(test, "unnamed copy", &contains_untouched,		&(struct contains_randstruct_shuffled){			/* full struct copy initializer */			.shuffled = shuffled,		}); 	test_check_mixed_init(test, "named", &mixed_untouched, &mixed_shuffled);	test_check_mixed_init(test, "unnamed", &mixed_untouched,		&(struct randstruct_mixed_shuffled){			init_members		}); 	test_check_funcs_init(test, "named", &funcs_untouched, &funcs_shuffled);	test_check_funcs_init(test, "unnamed", &funcs_untouched,		&(struct randstruct_funcs_shuffled){			DO_MANY_MEMBERS(func_member)		}); #undef func_member#undef init_members} static int randstruct_test_init(struct kunit *test){	if (!IS_ENABLED(CONFIG_RANDSTRUCT))		kunit_skip(test, "Not built with CONFIG_RANDSTRUCT=y"); 	return 0;} static struct kunit_case randstruct_test_cases[] = {	KUNIT_CASE(randstruct_layout_same),	KUNIT_CASE(randstruct_layout_mixed),	KUNIT_CASE(randstruct_layout_fptr),	KUNIT_CASE(randstruct_layout_fptr_deep),	KUNIT_CASE(randstruct_initializers),	{}}; static struct kunit_suite randstruct_test_suite = {	.name = "randstruct",	.init = randstruct_test_init,	.test_cases = randstruct_test_cases,}; kunit_test_suites(&randstruct_test_suite); MODULE_DESCRIPTION("Test cases for struct randomization");MODULE_LICENSE("GPL");