[linux-block.git] / lib / memcpy_kunit.c

// 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 {	\
	BUILD_BUG_ON(sizeof(instance.data) != 32);	\
	for (size_t 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 { \
	BUILD_BUG_ON(sizeof(one) != sizeof(two)); \
	for (size_t 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 after = {
		.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x72,
			  0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
			  0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
			  0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
			},
	};
	struct some_bytes startat = {
		.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
			  0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
			  0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
			  0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
			},
	};
	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);

	/* Verify memset_after() */
	dest = control;
	memset_after(&dest, 0x72, three);
	compare("memset_after()", dest, after);

	/* Verify memset_startat() */
	dest = control;
	memset_startat(&dest, 0x79, four);
	compare("memset_startat()", dest, startat);
#undef TEST_OP
}

static void strtomem_test(struct kunit *test)
{
	static const char input[sizeof(unsigned long)] = "hi";
	static const char truncate[] = "this is too long";
	struct {
		unsigned long canary1;
		unsigned char output[sizeof(unsigned long)] __nonstring;
		unsigned long canary2;
	} wrap;

	memset(&wrap, 0xFF, sizeof(wrap));
	KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX,
			    "bad initial canary value");
	KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX,
			    "bad initial canary value");

	/* Check unpadded copy leaves surroundings untouched. */
	strtomem(wrap.output, input);
	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
	KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
	for (size_t i = 2; i < sizeof(wrap.output); i++)
		KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF);
	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);

	/* Check truncated copy leaves surroundings untouched. */
	memset(&wrap, 0xFF, sizeof(wrap));
	strtomem(wrap.output, truncate);
	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	for (size_t i = 0; i < sizeof(wrap.output); i++)
		KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);

	/* Check padded copy leaves only string padded. */
	memset(&wrap, 0xFF, sizeof(wrap));
	strtomem_pad(wrap.output, input, 0xAA);
	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
	KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
	for (size_t i = 2; i < sizeof(wrap.output); i++)
		KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA);
	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);

	/* Check truncated padded copy has no padding. */
	memset(&wrap, 0xFF, sizeof(wrap));
	strtomem(wrap.output, truncate);
	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	for (size_t i = 0; i < sizeof(wrap.output); i++)
		KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
}

static struct kunit_case memcpy_test_cases[] = {
	KUNIT_CASE(memset_test),
	KUNIT_CASE(memcpy_test),
	KUNIT_CASE(memmove_test),
	KUNIT_CASE(strtomem_test),
	{}
};

static struct kunit_suite memcpy_test_suite = {
	.name = "memcpy",
	.test_cases = memcpy_test_cases,
};

kunit_test_suite(memcpy_test_suite);

MODULE_LICENSE("GPL");
Commit	Line	Data
bb95ebbe KC	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Test cases for memcpy(), memmove(), and memset().
	4	*/
	5	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	6
	7	#include <kunit/test.h>
	8	#include <linux/device.h>
	9	#include <linux/init.h>
	10	#include <linux/kernel.h>
	11	#include <linux/mm.h>
	12	#include <linux/module.h>
	13	#include <linux/overflow.h>
	14	#include <linux/slab.h>
	15	#include <linux/types.h>
	16	#include <linux/vmalloc.h>
	17
	18	struct some_bytes {
	19	union {
	20	u8 data[32];
	21	struct {
	22	u32 one;
	23	u16 two;
	24	u8 three;
	25	/* 1 byte hole */
	26	u32 four[4];
	27	};
	28	};
	29	};
	30
	31	#define check(instance, v) do { \
bb95ebbe	32	BUILD_BUG_ON(sizeof(instance.data) != 32); \
dfbafa70	33	for (size_t i = 0; i < sizeof(instance.data); i++) { \
bb95ebbe KC	34	KUNIT_ASSERT_EQ_MSG(test, instance.data[i], v, \
	35	"line %d: '%s' not initialized to 0x%02x @ %d (saw 0x%02x)\n", \
	36	__LINE__, #instance, v, i, instance.data[i]); \
	37	} \
	38	} while (0)
	39
	40	#define compare(name, one, two) do { \
bb95ebbe	41	BUILD_BUG_ON(sizeof(one) != sizeof(two)); \
dfbafa70	42	for (size_t i = 0; i < sizeof(one); i++) { \
bb95ebbe KC	43	KUNIT_EXPECT_EQ_MSG(test, one.data[i], two.data[i], \
	44	"line %d: %s.data[%d] (0x%02x) != %s.data[%d] (0x%02x)\n", \
	45	__LINE__, #one, i, one.data[i], #two, i, two.data[i]); \
	46	} \
	47	kunit_info(test, "ok: " TEST_OP "() " name "\n"); \
	48	} while (0)
	49
	50	static void memcpy_test(struct kunit *test)
	51	{
	52	#define TEST_OP "memcpy"
	53	struct some_bytes control = {
	54	.data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	55	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	56	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	57	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	58	},
	59	};
	60	struct some_bytes zero = { };
	61	struct some_bytes middle = {
	62	.data = { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	63	0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00,
	64	0x00, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
	65	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	66	},
	67	};
	68	struct some_bytes three = {
	69	.data = { 0x00, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	70	0x20, 0x00, 0x00, 0x20, 0x20, 0x20, 0x20, 0x20,
	71	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	72	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
	73	},
	74	};
	75	struct some_bytes dest = { };
	76	int count;
	77	u8 *ptr;
	78
	79	/* Verify static initializers. */
	80	check(control, 0x20);
	81	check(zero, 0);
	82	compare("static initializers", dest, zero);
	83
	84	/* Verify assignment. */
	85	dest = control;
	86	compare("direct assignment", dest, control);
	87
	88	/* Verify complete overwrite. */
	89	memcpy(dest.data, zero.data, sizeof(dest.data));
	90	compare("complete overwrite", dest, zero);
	91
	92	/* Verify middle overwrite. */
	93	dest = control;
	94	memcpy(dest.data + 12, zero.data, 7);
	95	compare("middle overwrite", dest, middle);
	96
	97	/* Verify argument side-effects aren't repeated. */
	98	dest = control;
	99	ptr = dest.data;
	100	count = 1;
	101	memcpy(ptr++, zero.data, count++);
	102	ptr += 8;
	103	memcpy(ptr++, zero.data, count++);
	104	compare("argument side-effects", dest, three);
	105	#undef TEST_OP
	106	}
107
108	static void memmove_test(struct kunit *test)
109	{
110	#define TEST_OP "memmove"
111	struct some_bytes control = {
112	.data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
113	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
114	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
115	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
116	},
117	};
118	struct some_bytes zero = { };
119	struct some_bytes middle = {
120	.data = { 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
121	0x99, 0x99, 0x99, 0x99, 0x00, 0x00, 0x00, 0x00,
122	0x00, 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99,
123	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
124	},
125	};
126	struct some_bytes five = {
127	.data = { 0x00, 0x00, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
128	0x99, 0x99, 0x00, 0x00, 0x00, 0x99, 0x99, 0x99,
129	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
130	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
131	},
132	};
133	struct some_bytes overlap = {
134	.data = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
135	0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
136	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
137	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
138	},
139	};
140	struct some_bytes overlap_expected = {
141	.data = { 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x07,
142	0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
143	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
144	0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
145	},
146	};
147	struct some_bytes dest = { };
148	int count;
149	u8 *ptr;
150
151	/* Verify static initializers. */
152	check(control, 0x99);
153	check(zero, 0);
154	compare("static initializers", zero, dest);
155
156	/* Verify assignment. */
157	dest = control;
158	compare("direct assignment", dest, control);
159
160	/* Verify complete overwrite. */
161	memmove(dest.data, zero.data, sizeof(dest.data));
162	compare("complete overwrite", dest, zero);
163
164	/* Verify middle overwrite. */
165	dest = control;
166	memmove(dest.data + 12, zero.data, 7);
167	compare("middle overwrite", dest, middle);
168
169	/* Verify argument side-effects aren't repeated. */
170	dest = control;
171	ptr = dest.data;
172	count = 2;
173	memmove(ptr++, zero.data, count++);
174	ptr += 9;
175	memmove(ptr++, zero.data, count++);
176	compare("argument side-effects", dest, five);
177
178	/* Verify overlapping overwrite is correct. */
179	ptr = &overlap.data[2];
180	memmove(ptr, overlap.data, 5);
181	compare("overlapping write", overlap, overlap_expected);
182	#undef TEST_OP
183	}
184
185	static void memset_test(struct kunit *test)
186	{
187	#define TEST_OP "memset"
188	struct some_bytes control = {
189	.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
190	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
191	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
192	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
193	},
194	};
195	struct some_bytes complete = {
196	.data = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
197	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
198	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
199	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
200	},
201	};
202	struct some_bytes middle = {
203	.data = { 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31,
204	0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
205	0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30,
206	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
207	},
208	};
209	struct some_bytes three = {
210	.data = { 0x60, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
211	0x30, 0x61, 0x61, 0x30, 0x30, 0x30, 0x30, 0x30,
212	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
213	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
214	},
215	};
4797632f KC	216	struct some_bytes after = {
	217	.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x72,
	218	0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
	219	0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
	220	0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72,
	221	},
	222	};
6dbefad4 KC	223	struct some_bytes startat = {
	224	.data = { 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
	225	0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
	226	0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
	227	0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79,
	228	},
	229	};
bb95ebbe KC	230	struct some_bytes dest = { };
	231	int count, value;
	232	u8 *ptr;
	233
	234	/* Verify static initializers. */
	235	check(control, 0x30);
	236	check(dest, 0);
	237
	238	/* Verify assignment. */
	239	dest = control;
	240	compare("direct assignment", dest, control);
	241
	242	/* Verify complete overwrite. */
	243	memset(dest.data, 0xff, sizeof(dest.data));
	244	compare("complete overwrite", dest, complete);
	245
	246	/* Verify middle overwrite. */
	247	dest = control;
	248	memset(dest.data + 4, 0x31, 16);
	249	compare("middle overwrite", dest, middle);
	250
	251	/* Verify argument side-effects aren't repeated. */
	252	dest = control;
	253	ptr = dest.data;
	254	value = 0x60;
	255	count = 1;
	256	memset(ptr++, value++, count++);
	257	ptr += 8;
	258	memset(ptr++, value++, count++);
	259	compare("argument side-effects", dest, three);
4797632f KC	260
	261	/* Verify memset_after() */
	262	dest = control;
	263	memset_after(&dest, 0x72, three);
	264	compare("memset_after()", dest, after);
	265
6dbefad4 KC	266	/* Verify memset_startat() */
	267	dest = control;
	268	memset_startat(&dest, 0x79, four);
	269	compare("memset_startat()", dest, startat);
bb95ebbe KC	270	#undef TEST_OP
	271	}
	272
dfbafa70 KC	273	static void strtomem_test(struct kunit *test)
dfbafa70 KC	274	{
66cb2a36	275	static const char input[sizeof(unsigned long)] = "hi";
dfbafa70 KC	276	static const char truncate[] = "this is too long";
	277	struct {
	278	unsigned long canary1;
	279	unsigned char output[sizeof(unsigned long)] __nonstring;
	280	unsigned long canary2;
	281	} wrap;
	282
	283	memset(&wrap, 0xFF, sizeof(wrap));
	284	KUNIT_EXPECT_EQ_MSG(test, wrap.canary1, ULONG_MAX,
	285	"bad initial canary value");
	286	KUNIT_EXPECT_EQ_MSG(test, wrap.canary2, ULONG_MAX,
	287	"bad initial canary value");
	288
	289	/* Check unpadded copy leaves surroundings untouched. */
	290	strtomem(wrap.output, input);
	291	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	292	KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
	293	KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
	294	for (size_t i = 2; i < sizeof(wrap.output); i++)
	295	KUNIT_EXPECT_EQ(test, wrap.output[i], 0xFF);
	296	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
	297
	298	/* Check truncated copy leaves surroundings untouched. */
	299	memset(&wrap, 0xFF, sizeof(wrap));
	300	strtomem(wrap.output, truncate);
	301	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	302	for (size_t i = 0; i < sizeof(wrap.output); i++)
	303	KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
	304	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
	305
	306	/* Check padded copy leaves only string padded. */
	307	memset(&wrap, 0xFF, sizeof(wrap));
	308	strtomem_pad(wrap.output, input, 0xAA);
	309	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	310	KUNIT_EXPECT_EQ(test, wrap.output[0], input[0]);
	311	KUNIT_EXPECT_EQ(test, wrap.output[1], input[1]);
	312	for (size_t i = 2; i < sizeof(wrap.output); i++)
	313	KUNIT_EXPECT_EQ(test, wrap.output[i], 0xAA);
	314	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
	315
	316	/* Check truncated padded copy has no padding. */
	317	memset(&wrap, 0xFF, sizeof(wrap));
	318	strtomem(wrap.output, truncate);
	319	KUNIT_EXPECT_EQ(test, wrap.canary1, ULONG_MAX);
	320	for (size_t i = 0; i < sizeof(wrap.output); i++)
	321	KUNIT_EXPECT_EQ(test, wrap.output[i], truncate[i]);
	322	KUNIT_EXPECT_EQ(test, wrap.canary2, ULONG_MAX);
	323	}
	324
bb95ebbe KC	325	static struct kunit_case memcpy_test_cases[] = {
	326	KUNIT_CASE(memset_test),
	327	KUNIT_CASE(memcpy_test),
	328	KUNIT_CASE(memmove_test),
dfbafa70	329	KUNIT_CASE(strtomem_test),
bb95ebbe KC	330	{}
	331	};
	332
	333	static struct kunit_suite memcpy_test_suite = {
	334	.name = "memcpy",
	335	.test_cases = memcpy_test_cases,
	336	};
	337
	338	kunit_test_suite(memcpy_test_suite);
	339
	340	MODULE_LICENSE("GPL");