Commit bb95ebbe authored by Kees Cook's avatar Kees Cook
Browse files

lib: Introduce CONFIG_MEMCPY_KUNIT_TEST 



Before changing anything about memcpy(), memmove(), and memset(), add
run-time tests to check basic behaviors for any regressions.

Signed-off-by: default avatarKees Cook <keescook@chromium.org>
parent be58f710

lib/Kconfig.debug

+11 −0
Original line number Diff line number Diff line
@@ -2452,6 +2452,17 @@ config RATIONAL_KUNIT_TEST 


	  If unsure, say N.



config MEMCPY_KUNIT_TEST

	tristate "Test memcpy(), memmove(), and memset() functions at runtime" if !KUNIT_ALL_TESTS

	depends on KUNIT

	default KUNIT_ALL_TESTS

	help

	  Builds unit tests for memcpy(), memmove(), and memset() functions.

	  For more information on KUnit and unit tests in general please refer

	  to the KUnit documentation in Documentation/dev-tools/kunit/.



	  If unsure, say N.



config TEST_UDELAY

	tristate "udelay test driver"

	help

lib/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -358,6 +358,7 @@ obj-$(CONFIG_LINEAR_RANGES_TEST) += test_linear_ranges.o 
obj-$(CONFIG_BITS_TEST) += test_bits.o

obj-$(CONFIG_CMDLINE_KUNIT_TEST) += cmdline_kunit.o

obj-$(CONFIG_SLUB_KUNIT_TEST) += slub_kunit.o

obj-$(CONFIG_MEMCPY_KUNIT_TEST) += memcpy_kunit.o



obj-$(CONFIG_GENERIC_LIB_DEVMEM_IS_ALLOWED) += devmem_is_allowed.o

lib/memcpy_kunit.c

0 → 100644
+265 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Test cases for memcpy(), memmove(), and memset().

 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <kunit/test.h>

#include <linux/device.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/mm.h>

#include <linux/module.h>

#include <linux/overflow.h>

#include <linux/slab.h>

#include <linux/types.h>

#include <linux/vmalloc.h>



struct some_bytes {

	union {

		u8 data[32];

		struct {

			u32 one;

			u16 two;

			u8  three;

			/* 1 byte hole */

			u32 four[4];

		};

	};

};



#define check(instance, v) do {	\

	int i;	\

	BUILD_BUG_ON(sizeof(instance.data) != 32);	\

	for (i = 0; i < sizeof(instance.data); i++) {	\

		KUNIT_ASSERT_EQ_MSG(test, instance.data[i], v, \

			"line %d: '%s' not initialized to 0x%02x @ %d (saw 0x%02x)\n", \

			__LINE__, #instance, v, i, instance.data[i]);	\

	}	\

} while (0)



#define compare(name, one, two) do { \

	int i; \

	BUILD_BUG_ON(sizeof(one) != sizeof(two)); \

	for (i = 0; i < sizeof(one); i++) {	\

		KUNIT_EXPECT_EQ_MSG(test, one.data[i], two.data[i], \

			"line %d: %s.data[%d] (0x%02x) != %s.data[%d] (0x%02x)\n", \

			__LINE__, #one, i, one.data[i], #two, i, two.data[i]); \

	}	\

	kunit_info(test, "ok: " TEST_OP "() " name "\n");	\

} while (0)



static void memcpy_test(struct kunit *test)

{

#define TEST_OP "memcpy"

	struct some_bytes control = {

		.data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			},

	};

	struct some_bytes zero = { };

	struct some_bytes middle = {

		.data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,

			  0x00, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			},

	};

	struct some_bytes three = {

		.data = { 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,

			},

	};

	struct some_bytes dest = { };

	int count;

	u8 *ptr;



	/* Verify static initializers. */

	check(control, 0x20);

	check(zero, 0);

	compare("static initializers", dest, zero);



	/* Verify assignment. */

	dest = control;

	compare("direct assignment", dest, control);



	/* Verify complete overwrite. */

	memcpy(dest.data, zero.data, sizeof(dest.data));

	compare("complete overwrite", dest, zero);



	/* Verify middle overwrite. */

	dest = control;

	memcpy(dest.data + 12, zero.data, 7);

	compare("middle overwrite", dest, middle);



	/* Verify argument side-effects aren't repeated. */

	dest = control;

	ptr = dest.data;

	count = 1;

	memcpy(ptr++, zero.data, count++);

	ptr += 8;

	memcpy(ptr++, zero.data, count++);

	compare("argument side-effects", dest, three);

#undef TEST_OP

}



static void memmove_test(struct kunit *test)

{

#define TEST_OP "memmove"

	struct some_bytes control = {

		.data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			},

	};

	struct some_bytes zero = { };

	struct some_bytes middle = {

		.data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00,

			  0x00, 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			},

	};

	struct some_bytes five = {

		.data = { 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x00, 0x00, 0x00, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			},

	};

	struct some_bytes overlap = {

		.data = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,

			  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			},

	};

	struct some_bytes overlap_expected = {

		.data = { 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x07,

			  0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			  0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,

			},

	};

	struct some_bytes dest = { };

	int count;

	u8 *ptr;



	/* Verify static initializers. */

	check(control, 0x99);

	check(zero, 0);

	compare("static initializers", zero, dest);



	/* Verify assignment. */

	dest = control;

	compare("direct assignment", dest, control);



	/* Verify complete overwrite. */

	memmove(dest.data, zero.data, sizeof(dest.data));

	compare("complete overwrite", dest, zero);



	/* Verify middle overwrite. */

	dest = control;

	memmove(dest.data + 12, zero.data, 7);

	compare("middle overwrite", dest, middle);



	/* Verify argument side-effects aren't repeated. */

	dest = control;

	ptr = dest.data;

	count = 2;

	memmove(ptr++, zero.data, count++);

	ptr += 9;

	memmove(ptr++, zero.data, count++);

	compare("argument side-effects", dest, five);



	/* Verify overlapping overwrite is correct. */

	ptr = &overlap.data[2];

	memmove(ptr, overlap.data, 5);

	compare("overlapping write", overlap, overlap_expected);

#undef TEST_OP

}



static void memset_test(struct kunit *test)

{

#define TEST_OP "memset"

	struct some_bytes control = {

		.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			},

	};

	struct some_bytes complete = {

		.data = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

			  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

			  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

			  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

			},

	};

	struct some_bytes middle = {

		.data = { 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31,

			  0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,

			  0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			},

	};

	struct some_bytes three = {

		.data = { 0x60, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			  0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,

			},

	};

	struct some_bytes dest = { };

	int count, value;

	u8 *ptr;



	/* Verify static initializers. */

	check(control, 0x30);

	check(dest, 0);



	/* Verify assignment. */

	dest = control;

	compare("direct assignment", dest, control);



	/* Verify complete overwrite. */

	memset(dest.data, 0xff, sizeof(dest.data));

	compare("complete overwrite", dest, complete);



	/* Verify middle overwrite. */

	dest = control;

	memset(dest.data + 4, 0x31, 16);

	compare("middle overwrite", dest, middle);



	/* Verify argument side-effects aren't repeated. */

	dest = control;

	ptr = dest.data;

	value = 0x60;

	count = 1;

	memset(ptr++, value++, count++);

	ptr += 8;

	memset(ptr++, value++, count++);

	compare("argument side-effects", dest, three);

#undef TEST_OP

}



static struct kunit_case memcpy_test_cases[] = {

	KUNIT_CASE(memset_test),

	KUNIT_CASE(memcpy_test),

	KUNIT_CASE(memmove_test),

	{}

};



static struct kunit_suite memcpy_test_suite = {

	.name = "memcpy",

	.test_cases = memcpy_test_cases,

};



kunit_test_suite(memcpy_test_suite);



MODULE_LICENSE("GPL");