1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 /*
3  * Test cases for arithmetic overflow checks. See:
4  * "Running tests with kunit_tool" at Documentation/dev-tools/kunit/start.rst
5  *	./tools/testing/kunit/kunit.py run overflow [--raw_output]
6  */
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8 
9 #include <kunit/test.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/mm.h>
13 #include <linux/module.h>
14 #include <linux/overflow.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
17 #include <linux/vmalloc.h>
18 
19 #define SKIP(cond, reason)		do {			\
20 	if (cond) {						\
21 		kunit_skip(test, reason);			\
22 		return;						\
23 	}							\
24 } while (0)
25 
26 /*
27  * Clang 11 and earlier generate unwanted libcalls for signed output
28  * on unsigned input.
29  */
30 #if defined(CONFIG_CC_IS_CLANG) && __clang_major__ <= 11
31 # define SKIP_SIGN_MISMATCH(t)	SKIP(t, "Clang 11 unwanted libcalls")
32 #else
33 # define SKIP_SIGN_MISMATCH(t)	do { } while (0)
34 #endif
35 
36 /*
37  * Clang 13 and earlier generate unwanted libcalls for 64-bit tests on
38  * 32-bit hosts.
39  */
40 #if defined(CONFIG_CC_IS_CLANG) && __clang_major__ <= 13 &&	\
41     BITS_PER_LONG != 64
42 # define SKIP_64_ON_32(t)	SKIP(t, "Clang 13 unwanted libcalls")
43 #else
44 # define SKIP_64_ON_32(t)	do { } while (0)
45 #endif
46 
47 #define DEFINE_TEST_ARRAY_TYPED(t1, t2, t)			\
48 	static const struct test_ ## t1 ## _ ## t2 ## __ ## t {	\
49 		t1 a;						\
50 		t2 b;						\
51 		t sum, diff, prod;				\
52 		bool s_of, d_of, p_of;				\
53 	} t1 ## _ ## t2 ## __ ## t ## _tests[]
54 
55 #define DEFINE_TEST_ARRAY(t)	DEFINE_TEST_ARRAY_TYPED(t, t, t)
56 
57 DEFINE_TEST_ARRAY(u8) = {
58 	{0, 0, 0, 0, 0, false, false, false},
59 	{1, 1, 2, 0, 1, false, false, false},
60 	{0, 1, 1, U8_MAX, 0, false, true, false},
61 	{1, 0, 1, 1, 0, false, false, false},
62 	{0, U8_MAX, U8_MAX, 1, 0, false, true, false},
63 	{U8_MAX, 0, U8_MAX, U8_MAX, 0, false, false, false},
64 	{1, U8_MAX, 0, 2, U8_MAX, true, true, false},
65 	{U8_MAX, 1, 0, U8_MAX-1, U8_MAX, true, false, false},
66 	{U8_MAX, U8_MAX, U8_MAX-1, 0, 1, true, false, true},
67 
68 	{U8_MAX, U8_MAX-1, U8_MAX-2, 1, 2, true, false, true},
69 	{U8_MAX-1, U8_MAX, U8_MAX-2, U8_MAX, 2, true, true, true},
70 
71 	{1U << 3, 1U << 3, 1U << 4, 0, 1U << 6, false, false, false},
72 	{1U << 4, 1U << 4, 1U << 5, 0, 0, false, false, true},
73 	{1U << 4, 1U << 3, 3*(1U << 3), 1U << 3, 1U << 7, false, false, false},
74 	{1U << 7, 1U << 7, 0, 0, 0, true, false, true},
75 
76 	{48, 32, 80, 16, 0, false, false, true},
77 	{128, 128, 0, 0, 0, true, false, true},
78 	{123, 234, 101, 145, 110, true, true, true},
79 };
80 DEFINE_TEST_ARRAY(u16) = {
81 	{0, 0, 0, 0, 0, false, false, false},
82 	{1, 1, 2, 0, 1, false, false, false},
83 	{0, 1, 1, U16_MAX, 0, false, true, false},
84 	{1, 0, 1, 1, 0, false, false, false},
85 	{0, U16_MAX, U16_MAX, 1, 0, false, true, false},
86 	{U16_MAX, 0, U16_MAX, U16_MAX, 0, false, false, false},
87 	{1, U16_MAX, 0, 2, U16_MAX, true, true, false},
88 	{U16_MAX, 1, 0, U16_MAX-1, U16_MAX, true, false, false},
89 	{U16_MAX, U16_MAX, U16_MAX-1, 0, 1, true, false, true},
90 
91 	{U16_MAX, U16_MAX-1, U16_MAX-2, 1, 2, true, false, true},
92 	{U16_MAX-1, U16_MAX, U16_MAX-2, U16_MAX, 2, true, true, true},
93 
94 	{1U << 7, 1U << 7, 1U << 8, 0, 1U << 14, false, false, false},
95 	{1U << 8, 1U << 8, 1U << 9, 0, 0, false, false, true},
96 	{1U << 8, 1U << 7, 3*(1U << 7), 1U << 7, 1U << 15, false, false, false},
97 	{1U << 15, 1U << 15, 0, 0, 0, true, false, true},
98 
99 	{123, 234, 357, 65425, 28782, false, true, false},
100 	{1234, 2345, 3579, 64425, 10146, false, true, true},
101 };
102 DEFINE_TEST_ARRAY(u32) = {
103 	{0, 0, 0, 0, 0, false, false, false},
104 	{1, 1, 2, 0, 1, false, false, false},
105 	{0, 1, 1, U32_MAX, 0, false, true, false},
106 	{1, 0, 1, 1, 0, false, false, false},
107 	{0, U32_MAX, U32_MAX, 1, 0, false, true, false},
108 	{U32_MAX, 0, U32_MAX, U32_MAX, 0, false, false, false},
109 	{1, U32_MAX, 0, 2, U32_MAX, true, true, false},
110 	{U32_MAX, 1, 0, U32_MAX-1, U32_MAX, true, false, false},
111 	{U32_MAX, U32_MAX, U32_MAX-1, 0, 1, true, false, true},
112 
113 	{U32_MAX, U32_MAX-1, U32_MAX-2, 1, 2, true, false, true},
114 	{U32_MAX-1, U32_MAX, U32_MAX-2, U32_MAX, 2, true, true, true},
115 
116 	{1U << 15, 1U << 15, 1U << 16, 0, 1U << 30, false, false, false},
117 	{1U << 16, 1U << 16, 1U << 17, 0, 0, false, false, true},
118 	{1U << 16, 1U << 15, 3*(1U << 15), 1U << 15, 1U << 31, false, false, false},
119 	{1U << 31, 1U << 31, 0, 0, 0, true, false, true},
120 
121 	{-2U, 1U, -1U, -3U, -2U, false, false, false},
122 	{-4U, 5U, 1U, -9U, -20U, true, false, true},
123 };
124 
125 DEFINE_TEST_ARRAY(u64) = {
126 	{0, 0, 0, 0, 0, false, false, false},
127 	{1, 1, 2, 0, 1, false, false, false},
128 	{0, 1, 1, U64_MAX, 0, false, true, false},
129 	{1, 0, 1, 1, 0, false, false, false},
130 	{0, U64_MAX, U64_MAX, 1, 0, false, true, false},
131 	{U64_MAX, 0, U64_MAX, U64_MAX, 0, false, false, false},
132 	{1, U64_MAX, 0, 2, U64_MAX, true, true, false},
133 	{U64_MAX, 1, 0, U64_MAX-1, U64_MAX, true, false, false},
134 	{U64_MAX, U64_MAX, U64_MAX-1, 0, 1, true, false, true},
135 
136 	{U64_MAX, U64_MAX-1, U64_MAX-2, 1, 2, true, false, true},
137 	{U64_MAX-1, U64_MAX, U64_MAX-2, U64_MAX, 2, true, true, true},
138 
139 	{1ULL << 31, 1ULL << 31, 1ULL << 32, 0, 1ULL << 62, false, false, false},
140 	{1ULL << 32, 1ULL << 32, 1ULL << 33, 0, 0, false, false, true},
141 	{1ULL << 32, 1ULL << 31, 3*(1ULL << 31), 1ULL << 31, 1ULL << 63, false, false, false},
142 	{1ULL << 63, 1ULL << 63, 0, 0, 0, true, false, true},
143 	{1000000000ULL /* 10^9 */, 10000000000ULL /* 10^10 */,
144 	 11000000000ULL, 18446744064709551616ULL, 10000000000000000000ULL,
145 	 false, true, false},
146 	{-15ULL, 10ULL, -5ULL, -25ULL, -150ULL, false, false, true},
147 };
148 
149 DEFINE_TEST_ARRAY(s8) = {
150 	{0, 0, 0, 0, 0, false, false, false},
151 
152 	{0, S8_MAX, S8_MAX, -S8_MAX, 0, false, false, false},
153 	{S8_MAX, 0, S8_MAX, S8_MAX, 0, false, false, false},
154 	{0, S8_MIN, S8_MIN, S8_MIN, 0, false, true, false},
155 	{S8_MIN, 0, S8_MIN, S8_MIN, 0, false, false, false},
156 
157 	{-1, S8_MIN, S8_MAX, S8_MAX, S8_MIN, true, false, true},
158 	{S8_MIN, -1, S8_MAX, -S8_MAX, S8_MIN, true, false, true},
159 	{-1, S8_MAX, S8_MAX-1, S8_MIN, -S8_MAX, false, false, false},
160 	{S8_MAX, -1, S8_MAX-1, S8_MIN, -S8_MAX, false, true, false},
161 	{-1, -S8_MAX, S8_MIN, S8_MAX-1, S8_MAX, false, false, false},
162 	{-S8_MAX, -1, S8_MIN, S8_MIN+2, S8_MAX, false, false, false},
163 
164 	{1, S8_MIN, -S8_MAX, -S8_MAX, S8_MIN, false, true, false},
165 	{S8_MIN, 1, -S8_MAX, S8_MAX, S8_MIN, false, true, false},
166 	{1, S8_MAX, S8_MIN, S8_MIN+2, S8_MAX, true, false, false},
167 	{S8_MAX, 1, S8_MIN, S8_MAX-1, S8_MAX, true, false, false},
168 
169 	{S8_MIN, S8_MIN, 0, 0, 0, true, false, true},
170 	{S8_MAX, S8_MAX, -2, 0, 1, true, false, true},
171 
172 	{-4, -32, -36, 28, -128, false, false, true},
173 	{-4, 32, 28, -36, -128, false, false, false},
174 };
175 
176 DEFINE_TEST_ARRAY(s16) = {
177 	{0, 0, 0, 0, 0, false, false, false},
178 
179 	{0, S16_MAX, S16_MAX, -S16_MAX, 0, false, false, false},
180 	{S16_MAX, 0, S16_MAX, S16_MAX, 0, false, false, false},
181 	{0, S16_MIN, S16_MIN, S16_MIN, 0, false, true, false},
182 	{S16_MIN, 0, S16_MIN, S16_MIN, 0, false, false, false},
183 
184 	{-1, S16_MIN, S16_MAX, S16_MAX, S16_MIN, true, false, true},
185 	{S16_MIN, -1, S16_MAX, -S16_MAX, S16_MIN, true, false, true},
186 	{-1, S16_MAX, S16_MAX-1, S16_MIN, -S16_MAX, false, false, false},
187 	{S16_MAX, -1, S16_MAX-1, S16_MIN, -S16_MAX, false, true, false},
188 	{-1, -S16_MAX, S16_MIN, S16_MAX-1, S16_MAX, false, false, false},
189 	{-S16_MAX, -1, S16_MIN, S16_MIN+2, S16_MAX, false, false, false},
190 
191 	{1, S16_MIN, -S16_MAX, -S16_MAX, S16_MIN, false, true, false},
192 	{S16_MIN, 1, -S16_MAX, S16_MAX, S16_MIN, false, true, false},
193 	{1, S16_MAX, S16_MIN, S16_MIN+2, S16_MAX, true, false, false},
194 	{S16_MAX, 1, S16_MIN, S16_MAX-1, S16_MAX, true, false, false},
195 
196 	{S16_MIN, S16_MIN, 0, 0, 0, true, false, true},
197 	{S16_MAX, S16_MAX, -2, 0, 1, true, false, true},
198 };
199 DEFINE_TEST_ARRAY(s32) = {
200 	{0, 0, 0, 0, 0, false, false, false},
201 
202 	{0, S32_MAX, S32_MAX, -S32_MAX, 0, false, false, false},
203 	{S32_MAX, 0, S32_MAX, S32_MAX, 0, false, false, false},
204 	{0, S32_MIN, S32_MIN, S32_MIN, 0, false, true, false},
205 	{S32_MIN, 0, S32_MIN, S32_MIN, 0, false, false, false},
206 
207 	{-1, S32_MIN, S32_MAX, S32_MAX, S32_MIN, true, false, true},
208 	{S32_MIN, -1, S32_MAX, -S32_MAX, S32_MIN, true, false, true},
209 	{-1, S32_MAX, S32_MAX-1, S32_MIN, -S32_MAX, false, false, false},
210 	{S32_MAX, -1, S32_MAX-1, S32_MIN, -S32_MAX, false, true, false},
211 	{-1, -S32_MAX, S32_MIN, S32_MAX-1, S32_MAX, false, false, false},
212 	{-S32_MAX, -1, S32_MIN, S32_MIN+2, S32_MAX, false, false, false},
213 
214 	{1, S32_MIN, -S32_MAX, -S32_MAX, S32_MIN, false, true, false},
215 	{S32_MIN, 1, -S32_MAX, S32_MAX, S32_MIN, false, true, false},
216 	{1, S32_MAX, S32_MIN, S32_MIN+2, S32_MAX, true, false, false},
217 	{S32_MAX, 1, S32_MIN, S32_MAX-1, S32_MAX, true, false, false},
218 
219 	{S32_MIN, S32_MIN, 0, 0, 0, true, false, true},
220 	{S32_MAX, S32_MAX, -2, 0, 1, true, false, true},
221 };
222 
223 DEFINE_TEST_ARRAY(s64) = {
224 	{0, 0, 0, 0, 0, false, false, false},
225 
226 	{0, S64_MAX, S64_MAX, -S64_MAX, 0, false, false, false},
227 	{S64_MAX, 0, S64_MAX, S64_MAX, 0, false, false, false},
228 	{0, S64_MIN, S64_MIN, S64_MIN, 0, false, true, false},
229 	{S64_MIN, 0, S64_MIN, S64_MIN, 0, false, false, false},
230 
231 	{-1, S64_MIN, S64_MAX, S64_MAX, S64_MIN, true, false, true},
232 	{S64_MIN, -1, S64_MAX, -S64_MAX, S64_MIN, true, false, true},
233 	{-1, S64_MAX, S64_MAX-1, S64_MIN, -S64_MAX, false, false, false},
234 	{S64_MAX, -1, S64_MAX-1, S64_MIN, -S64_MAX, false, true, false},
235 	{-1, -S64_MAX, S64_MIN, S64_MAX-1, S64_MAX, false, false, false},
236 	{-S64_MAX, -1, S64_MIN, S64_MIN+2, S64_MAX, false, false, false},
237 
238 	{1, S64_MIN, -S64_MAX, -S64_MAX, S64_MIN, false, true, false},
239 	{S64_MIN, 1, -S64_MAX, S64_MAX, S64_MIN, false, true, false},
240 	{1, S64_MAX, S64_MIN, S64_MIN+2, S64_MAX, true, false, false},
241 	{S64_MAX, 1, S64_MIN, S64_MAX-1, S64_MAX, true, false, false},
242 
243 	{S64_MIN, S64_MIN, 0, 0, 0, true, false, true},
244 	{S64_MAX, S64_MAX, -2, 0, 1, true, false, true},
245 
246 	{-1, -1, -2, 0, 1, false, false, false},
247 	{-1, -128, -129, 127, 128, false, false, false},
248 	{-128, -1, -129, -127, 128, false, false, false},
249 	{0, -S64_MAX, -S64_MAX, S64_MAX, 0, false, false, false},
250 };
251 
252 #define check_one_op(t, fmt, op, sym, a, b, r, of) do {			\
253 	int _a_orig = a, _a_bump = a + 1;				\
254 	int _b_orig = b, _b_bump = b + 1;				\
255 	bool _of;							\
256 	t _r;								\
257 									\
258 	_of = check_ ## op ## _overflow(a, b, &_r);			\
259 	KUNIT_EXPECT_EQ_MSG(test, _of, of,				\
260 		"expected "fmt" "sym" "fmt" to%s overflow (type %s)\n",	\
261 		a, b, of ? "" : " not", #t);				\
262 	KUNIT_EXPECT_EQ_MSG(test, _r, r,				\
263 		"expected "fmt" "sym" "fmt" == "fmt", got "fmt" (type %s)\n", \
264 		a, b, r, _r, #t);					\
265 	/* Check for internal macro side-effects. */			\
266 	_of = check_ ## op ## _overflow(_a_orig++, _b_orig++, &_r);	\
267 	KUNIT_EXPECT_EQ_MSG(test, _a_orig, _a_bump, "Unexpected " #op " macro side-effect!\n"); \
268 	KUNIT_EXPECT_EQ_MSG(test, _b_orig, _b_bump, "Unexpected " #op " macro side-effect!\n"); \
269 } while (0)
270 
271 #define DEFINE_TEST_FUNC_TYPED(n, t, fmt)				\
272 static void do_test_ ## n(struct kunit *test, const struct test_ ## n *p) \
273 {									\
274 	check_one_op(t, fmt, add, "+", p->a, p->b, p->sum, p->s_of);	\
275 	check_one_op(t, fmt, add, "+", p->b, p->a, p->sum, p->s_of);	\
276 	check_one_op(t, fmt, sub, "-", p->a, p->b, p->diff, p->d_of);	\
277 	check_one_op(t, fmt, mul, "*", p->a, p->b, p->prod, p->p_of);	\
278 	check_one_op(t, fmt, mul, "*", p->b, p->a, p->prod, p->p_of);	\
279 }									\
280 									\
281 static void n ## _overflow_test(struct kunit *test) {			\
282 	unsigned i;							\
283 									\
284 	SKIP_64_ON_32(__same_type(t, u64));				\
285 	SKIP_64_ON_32(__same_type(t, s64));				\
286 	SKIP_SIGN_MISMATCH(__same_type(n ## _tests[0].a, u32) &&	\
287 			   __same_type(n ## _tests[0].b, u32) &&	\
288 			   __same_type(n ## _tests[0].sum, int));	\
289 									\
290 	for (i = 0; i < ARRAY_SIZE(n ## _tests); ++i)			\
291 		do_test_ ## n(test, &n ## _tests[i]);			\
292 	kunit_info(test, "%zu %s arithmetic tests finished\n",		\
293 		ARRAY_SIZE(n ## _tests), #n);				\
294 }
295 
296 #define DEFINE_TEST_FUNC(t, fmt)					\
297 	DEFINE_TEST_FUNC_TYPED(t ## _ ## t ## __ ## t, t, fmt)
298 
299 DEFINE_TEST_FUNC(u8, "%d");
300 DEFINE_TEST_FUNC(s8, "%d");
301 DEFINE_TEST_FUNC(u16, "%d");
302 DEFINE_TEST_FUNC(s16, "%d");
303 DEFINE_TEST_FUNC(u32, "%u");
304 DEFINE_TEST_FUNC(s32, "%d");
305 DEFINE_TEST_FUNC(u64, "%llu");
306 DEFINE_TEST_FUNC(s64, "%lld");
307 
308 DEFINE_TEST_ARRAY_TYPED(u32, u32, u8) = {
309 	{0, 0, 0, 0, 0, false, false, false},
310 	{U8_MAX, 2, 1, U8_MAX - 2, U8_MAX - 1, true, false, true},
311 	{U8_MAX + 1, 0, 0, 0, 0, true, true, false},
312 };
313 DEFINE_TEST_FUNC_TYPED(u32_u32__u8, u8, "%d");
314 
315 DEFINE_TEST_ARRAY_TYPED(u32, u32, int) = {
316 	{0, 0, 0, 0, 0, false, false, false},
317 	{U32_MAX, 0, -1, -1, 0, true, true, false},
318 };
319 DEFINE_TEST_FUNC_TYPED(u32_u32__int, int, "%d");
320 
321 DEFINE_TEST_ARRAY_TYPED(u8, u8, int) = {
322 	{0, 0, 0, 0, 0, false, false, false},
323 	{U8_MAX, U8_MAX, 2 * U8_MAX, 0, U8_MAX * U8_MAX, false, false, false},
324 	{1, 2, 3, -1, 2, false, false, false},
325 };
326 DEFINE_TEST_FUNC_TYPED(u8_u8__int, int, "%d");
327 
328 DEFINE_TEST_ARRAY_TYPED(int, int, u8) = {
329 	{0, 0, 0, 0, 0, false, false, false},
330 	{1, 2, 3, U8_MAX, 2, false, true, false},
331 	{-1, 0, U8_MAX, U8_MAX, 0, true, true, false},
332 };
333 DEFINE_TEST_FUNC_TYPED(int_int__u8, u8, "%d");
334 
335 /* Args are: value, shift, type, expected result, overflow expected */
336 #define TEST_ONE_SHIFT(a, s, t, expect, of)	do {			\
337 	typeof(a) __a = (a);						\
338 	typeof(s) __s = (s);						\
339 	t __e = (expect);						\
340 	t __d;								\
341 	bool __of = check_shl_overflow(__a, __s, &__d);			\
342 	if (__of != of) {						\
343 		KUNIT_EXPECT_EQ_MSG(test, __of, of,			\
344 			"expected (%s)(%s << %s) to%s overflow\n",	\
345 			#t, #a, #s, of ? "" : " not");			\
346 	} else if (!__of && __d != __e) {				\
347 		KUNIT_EXPECT_EQ_MSG(test, __d, __e,			\
348 			"expected (%s)(%s << %s) == %s\n",		\
349 			#t, #a, #s, #expect);				\
350 		if ((t)-1 < 0)						\
351 			kunit_info(test, "got %lld\n", (s64)__d);	\
352 		else							\
353 			kunit_info(test, "got %llu\n", (u64)__d);	\
354 	}								\
355 	count++;							\
356 } while (0)
357 
shift_sane_test(struct kunit * test)358 static void shift_sane_test(struct kunit *test)
359 {
360 	int count = 0;
361 
362 	/* Sane shifts. */
363 	TEST_ONE_SHIFT(1, 0, u8, 1 << 0, false);
364 	TEST_ONE_SHIFT(1, 4, u8, 1 << 4, false);
365 	TEST_ONE_SHIFT(1, 7, u8, 1 << 7, false);
366 	TEST_ONE_SHIFT(0xF, 4, u8, 0xF << 4, false);
367 	TEST_ONE_SHIFT(1, 0, u16, 1 << 0, false);
368 	TEST_ONE_SHIFT(1, 10, u16, 1 << 10, false);
369 	TEST_ONE_SHIFT(1, 15, u16, 1 << 15, false);
370 	TEST_ONE_SHIFT(0xFF, 8, u16, 0xFF << 8, false);
371 	TEST_ONE_SHIFT(1, 0, int, 1 << 0, false);
372 	TEST_ONE_SHIFT(1, 16, int, 1 << 16, false);
373 	TEST_ONE_SHIFT(1, 30, int, 1 << 30, false);
374 	TEST_ONE_SHIFT(1, 0, s32, 1 << 0, false);
375 	TEST_ONE_SHIFT(1, 16, s32, 1 << 16, false);
376 	TEST_ONE_SHIFT(1, 30, s32, 1 << 30, false);
377 	TEST_ONE_SHIFT(1, 0, unsigned int, 1U << 0, false);
378 	TEST_ONE_SHIFT(1, 20, unsigned int, 1U << 20, false);
379 	TEST_ONE_SHIFT(1, 31, unsigned int, 1U << 31, false);
380 	TEST_ONE_SHIFT(0xFFFFU, 16, unsigned int, 0xFFFFU << 16, false);
381 	TEST_ONE_SHIFT(1, 0, u32, 1U << 0, false);
382 	TEST_ONE_SHIFT(1, 20, u32, 1U << 20, false);
383 	TEST_ONE_SHIFT(1, 31, u32, 1U << 31, false);
384 	TEST_ONE_SHIFT(0xFFFFU, 16, u32, 0xFFFFU << 16, false);
385 	TEST_ONE_SHIFT(1, 0, u64, 1ULL << 0, false);
386 	TEST_ONE_SHIFT(1, 40, u64, 1ULL << 40, false);
387 	TEST_ONE_SHIFT(1, 63, u64, 1ULL << 63, false);
388 	TEST_ONE_SHIFT(0xFFFFFFFFULL, 32, u64, 0xFFFFFFFFULL << 32, false);
389 
390 	/* Sane shift: start and end with 0, without a too-wide shift. */
391 	TEST_ONE_SHIFT(0, 7, u8, 0, false);
392 	TEST_ONE_SHIFT(0, 15, u16, 0, false);
393 	TEST_ONE_SHIFT(0, 31, unsigned int, 0, false);
394 	TEST_ONE_SHIFT(0, 31, u32, 0, false);
395 	TEST_ONE_SHIFT(0, 63, u64, 0, false);
396 
397 	/* Sane shift: start and end with 0, without reaching signed bit. */
398 	TEST_ONE_SHIFT(0, 6, s8, 0, false);
399 	TEST_ONE_SHIFT(0, 14, s16, 0, false);
400 	TEST_ONE_SHIFT(0, 30, int, 0, false);
401 	TEST_ONE_SHIFT(0, 30, s32, 0, false);
402 	TEST_ONE_SHIFT(0, 62, s64, 0, false);
403 
404 	kunit_info(test, "%d sane shift tests finished\n", count);
405 }
406 
shift_overflow_test(struct kunit * test)407 static void shift_overflow_test(struct kunit *test)
408 {
409 	int count = 0;
410 
411 	/* Overflow: shifted the bit off the end. */
412 	TEST_ONE_SHIFT(1, 8, u8, 0, true);
413 	TEST_ONE_SHIFT(1, 16, u16, 0, true);
414 	TEST_ONE_SHIFT(1, 32, unsigned int, 0, true);
415 	TEST_ONE_SHIFT(1, 32, u32, 0, true);
416 	TEST_ONE_SHIFT(1, 64, u64, 0, true);
417 
418 	/* Overflow: shifted into the signed bit. */
419 	TEST_ONE_SHIFT(1, 7, s8, 0, true);
420 	TEST_ONE_SHIFT(1, 15, s16, 0, true);
421 	TEST_ONE_SHIFT(1, 31, int, 0, true);
422 	TEST_ONE_SHIFT(1, 31, s32, 0, true);
423 	TEST_ONE_SHIFT(1, 63, s64, 0, true);
424 
425 	/* Overflow: high bit falls off unsigned types. */
426 	/* 10010110 */
427 	TEST_ONE_SHIFT(150, 1, u8, 0, true);
428 	/* 1000100010010110 */
429 	TEST_ONE_SHIFT(34966, 1, u16, 0, true);
430 	/* 10000100000010001000100010010110 */
431 	TEST_ONE_SHIFT(2215151766U, 1, u32, 0, true);
432 	TEST_ONE_SHIFT(2215151766U, 1, unsigned int, 0, true);
433 	/* 1000001000010000010000000100000010000100000010001000100010010110 */
434 	TEST_ONE_SHIFT(9372061470395238550ULL, 1, u64, 0, true);
435 
436 	/* Overflow: bit shifted into signed bit on signed types. */
437 	/* 01001011 */
438 	TEST_ONE_SHIFT(75, 1, s8, 0, true);
439 	/* 0100010001001011 */
440 	TEST_ONE_SHIFT(17483, 1, s16, 0, true);
441 	/* 01000010000001000100010001001011 */
442 	TEST_ONE_SHIFT(1107575883, 1, s32, 0, true);
443 	TEST_ONE_SHIFT(1107575883, 1, int, 0, true);
444 	/* 0100000100001000001000000010000001000010000001000100010001001011 */
445 	TEST_ONE_SHIFT(4686030735197619275LL, 1, s64, 0, true);
446 
447 	/* Overflow: bit shifted past signed bit on signed types. */
448 	/* 01001011 */
449 	TEST_ONE_SHIFT(75, 2, s8, 0, true);
450 	/* 0100010001001011 */
451 	TEST_ONE_SHIFT(17483, 2, s16, 0, true);
452 	/* 01000010000001000100010001001011 */
453 	TEST_ONE_SHIFT(1107575883, 2, s32, 0, true);
454 	TEST_ONE_SHIFT(1107575883, 2, int, 0, true);
455 	/* 0100000100001000001000000010000001000010000001000100010001001011 */
456 	TEST_ONE_SHIFT(4686030735197619275LL, 2, s64, 0, true);
457 
458 	kunit_info(test, "%d overflow shift tests finished\n", count);
459 }
460 
shift_truncate_test(struct kunit * test)461 static void shift_truncate_test(struct kunit *test)
462 {
463 	int count = 0;
464 
465 	/* Overflow: values larger than destination type. */
466 	TEST_ONE_SHIFT(0x100, 0, u8, 0, true);
467 	TEST_ONE_SHIFT(0xFF, 0, s8, 0, true);
468 	TEST_ONE_SHIFT(0x10000U, 0, u16, 0, true);
469 	TEST_ONE_SHIFT(0xFFFFU, 0, s16, 0, true);
470 	TEST_ONE_SHIFT(0x100000000ULL, 0, u32, 0, true);
471 	TEST_ONE_SHIFT(0x100000000ULL, 0, unsigned int, 0, true);
472 	TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, s32, 0, true);
473 	TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, int, 0, true);
474 	TEST_ONE_SHIFT(0xFFFFFFFFFFFFFFFFULL, 0, s64, 0, true);
475 
476 	/* Overflow: shifted at or beyond entire type's bit width. */
477 	TEST_ONE_SHIFT(0, 8, u8, 0, true);
478 	TEST_ONE_SHIFT(0, 9, u8, 0, true);
479 	TEST_ONE_SHIFT(0, 8, s8, 0, true);
480 	TEST_ONE_SHIFT(0, 9, s8, 0, true);
481 	TEST_ONE_SHIFT(0, 16, u16, 0, true);
482 	TEST_ONE_SHIFT(0, 17, u16, 0, true);
483 	TEST_ONE_SHIFT(0, 16, s16, 0, true);
484 	TEST_ONE_SHIFT(0, 17, s16, 0, true);
485 	TEST_ONE_SHIFT(0, 32, u32, 0, true);
486 	TEST_ONE_SHIFT(0, 33, u32, 0, true);
487 	TEST_ONE_SHIFT(0, 32, int, 0, true);
488 	TEST_ONE_SHIFT(0, 33, int, 0, true);
489 	TEST_ONE_SHIFT(0, 32, s32, 0, true);
490 	TEST_ONE_SHIFT(0, 33, s32, 0, true);
491 	TEST_ONE_SHIFT(0, 64, u64, 0, true);
492 	TEST_ONE_SHIFT(0, 65, u64, 0, true);
493 	TEST_ONE_SHIFT(0, 64, s64, 0, true);
494 	TEST_ONE_SHIFT(0, 65, s64, 0, true);
495 
496 	kunit_info(test, "%d truncate shift tests finished\n", count);
497 }
498 
shift_nonsense_test(struct kunit * test)499 static void shift_nonsense_test(struct kunit *test)
500 {
501 	int count = 0;
502 
503 	/* Nonsense: negative initial value. */
504 	TEST_ONE_SHIFT(-1, 0, s8, 0, true);
505 	TEST_ONE_SHIFT(-1, 0, u8, 0, true);
506 	TEST_ONE_SHIFT(-5, 0, s16, 0, true);
507 	TEST_ONE_SHIFT(-5, 0, u16, 0, true);
508 	TEST_ONE_SHIFT(-10, 0, int, 0, true);
509 	TEST_ONE_SHIFT(-10, 0, unsigned int, 0, true);
510 	TEST_ONE_SHIFT(-100, 0, s32, 0, true);
511 	TEST_ONE_SHIFT(-100, 0, u32, 0, true);
512 	TEST_ONE_SHIFT(-10000, 0, s64, 0, true);
513 	TEST_ONE_SHIFT(-10000, 0, u64, 0, true);
514 
515 	/* Nonsense: negative shift values. */
516 	TEST_ONE_SHIFT(0, -5, s8, 0, true);
517 	TEST_ONE_SHIFT(0, -5, u8, 0, true);
518 	TEST_ONE_SHIFT(0, -10, s16, 0, true);
519 	TEST_ONE_SHIFT(0, -10, u16, 0, true);
520 	TEST_ONE_SHIFT(0, -15, int, 0, true);
521 	TEST_ONE_SHIFT(0, -15, unsigned int, 0, true);
522 	TEST_ONE_SHIFT(0, -20, s32, 0, true);
523 	TEST_ONE_SHIFT(0, -20, u32, 0, true);
524 	TEST_ONE_SHIFT(0, -30, s64, 0, true);
525 	TEST_ONE_SHIFT(0, -30, u64, 0, true);
526 
527 	/*
528 	 * Corner case: for unsigned types, we fail when we've shifted
529 	 * through the entire width of bits. For signed types, we might
530 	 * want to match this behavior, but that would mean noticing if
531 	 * we shift through all but the signed bit, and this is not
532 	 * currently detected (but we'll notice an overflow into the
533 	 * signed bit). So, for now, we will test this condition but
534 	 * mark it as not expected to overflow.
535 	 */
536 	TEST_ONE_SHIFT(0, 7, s8, 0, false);
537 	TEST_ONE_SHIFT(0, 15, s16, 0, false);
538 	TEST_ONE_SHIFT(0, 31, int, 0, false);
539 	TEST_ONE_SHIFT(0, 31, s32, 0, false);
540 	TEST_ONE_SHIFT(0, 63, s64, 0, false);
541 
542 	kunit_info(test, "%d nonsense shift tests finished\n", count);
543 }
544 #undef TEST_ONE_SHIFT
545 
546 /*
547  * Deal with the various forms of allocator arguments. See comments above
548  * the DEFINE_TEST_ALLOC() instances for mapping of the "bits".
549  */
550 #define alloc_GFP		 (GFP_KERNEL | __GFP_NOWARN)
551 #define alloc010(alloc, arg, sz) alloc(sz, alloc_GFP)
552 #define alloc011(alloc, arg, sz) alloc(sz, alloc_GFP, NUMA_NO_NODE)
553 #define alloc000(alloc, arg, sz) alloc(sz)
554 #define alloc001(alloc, arg, sz) alloc(sz, NUMA_NO_NODE)
555 #define alloc110(alloc, arg, sz) alloc(arg, sz, alloc_GFP)
556 #define free0(free, arg, ptr)	 free(ptr)
557 #define free1(free, arg, ptr)	 free(arg, ptr)
558 
559 /* Wrap around to 16K */
560 #define TEST_SIZE		(5 * 4096)
561 
562 #define DEFINE_TEST_ALLOC(func, free_func, want_arg, want_gfp, want_node)\
563 static void test_ ## func (struct kunit *test, void *arg)		\
564 {									\
565 	volatile size_t a = TEST_SIZE;					\
566 	volatile size_t b = (SIZE_MAX / TEST_SIZE) + 1;			\
567 	void *ptr;							\
568 									\
569 	/* Tiny allocation test. */					\
570 	ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg, 1);\
571 	KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ptr,			\
572 			    #func " failed regular allocation?!\n");	\
573 	free ## want_arg (free_func, arg, ptr);				\
574 									\
575 	/* Wrapped allocation test. */					\
576 	ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg,	\
577 							  a * b);	\
578 	KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ptr,			\
579 			    #func " unexpectedly failed bad wrapping?!\n"); \
580 	free ## want_arg (free_func, arg, ptr);				\
581 									\
582 	/* Saturated allocation test. */				\
583 	ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg,	\
584 						   array_size(a, b));	\
585 	if (ptr) {							\
586 		KUNIT_FAIL(test, #func " missed saturation!\n");	\
587 		free ## want_arg (free_func, arg, ptr);			\
588 	}								\
589 }
590 
591 /*
592  * Allocator uses a trailing node argument --------+  (e.g. kmalloc_node())
593  * Allocator uses the gfp_t argument -----------+  |  (e.g. kmalloc())
594  * Allocator uses a special leading argument +  |  |  (e.g. devm_kmalloc())
595  *                                           |  |  |
596  */
597 DEFINE_TEST_ALLOC(kmalloc,	 kfree,	     0, 1, 0);
598 DEFINE_TEST_ALLOC(kmalloc_node,	 kfree,	     0, 1, 1);
599 DEFINE_TEST_ALLOC(kzalloc,	 kfree,	     0, 1, 0);
600 DEFINE_TEST_ALLOC(kzalloc_node,  kfree,	     0, 1, 1);
601 DEFINE_TEST_ALLOC(__vmalloc,	 vfree,	     0, 1, 0);
602 DEFINE_TEST_ALLOC(kvmalloc,	 kvfree,     0, 1, 0);
603 DEFINE_TEST_ALLOC(kvmalloc_node, kvfree,     0, 1, 1);
604 DEFINE_TEST_ALLOC(kvzalloc,	 kvfree,     0, 1, 0);
605 DEFINE_TEST_ALLOC(kvzalloc_node, kvfree,     0, 1, 1);
606 DEFINE_TEST_ALLOC(devm_kmalloc,  devm_kfree, 1, 1, 0);
607 DEFINE_TEST_ALLOC(devm_kzalloc,  devm_kfree, 1, 1, 0);
608 
overflow_allocation_test(struct kunit * test)609 static void overflow_allocation_test(struct kunit *test)
610 {
611 	const char device_name[] = "overflow-test";
612 	struct device *dev;
613 	int count = 0;
614 
615 #define check_allocation_overflow(alloc)	do {	\
616 	count++;					\
617 	test_ ## alloc(test, dev);			\
618 } while (0)
619 
620 	/* Create dummy device for devm_kmalloc()-family tests. */
621 	dev = root_device_register(device_name);
622 	KUNIT_ASSERT_FALSE_MSG(test, IS_ERR(dev),
623 			       "Cannot register test device\n");
624 
625 	check_allocation_overflow(kmalloc);
626 	check_allocation_overflow(kmalloc_node);
627 	check_allocation_overflow(kzalloc);
628 	check_allocation_overflow(kzalloc_node);
629 	check_allocation_overflow(__vmalloc);
630 	check_allocation_overflow(kvmalloc);
631 	check_allocation_overflow(kvmalloc_node);
632 	check_allocation_overflow(kvzalloc);
633 	check_allocation_overflow(kvzalloc_node);
634 	check_allocation_overflow(devm_kmalloc);
635 	check_allocation_overflow(devm_kzalloc);
636 
637 	device_unregister(dev);
638 
639 	kunit_info(test, "%d allocation overflow tests finished\n", count);
640 #undef check_allocation_overflow
641 }
642 
643 struct __test_flex_array {
644 	unsigned long flags;
645 	size_t count;
646 	unsigned long data[];
647 };
648 
overflow_size_helpers_test(struct kunit * test)649 static void overflow_size_helpers_test(struct kunit *test)
650 {
651 	/* Make sure struct_size() can be used in a constant expression. */
652 	u8 ce_array[struct_size((struct __test_flex_array *)0, data, 55)];
653 	struct __test_flex_array *obj;
654 	int count = 0;
655 	int var;
656 	volatile int unconst = 0;
657 
658 	/* Verify constant expression against runtime version. */
659 	var = 55;
660 	OPTIMIZER_HIDE_VAR(var);
661 	KUNIT_EXPECT_EQ(test, sizeof(ce_array), struct_size(obj, data, var));
662 
663 #define check_one_size_helper(expected, func, args...)	do {	\
664 	size_t _r = func(args);					\
665 	KUNIT_EXPECT_EQ_MSG(test, _r, expected,			\
666 		"expected " #func "(" #args ") to return %zu but got %zu instead\n", \
667 		(size_t)(expected), _r);			\
668 	count++;						\
669 } while (0)
670 
671 	var = 4;
672 	check_one_size_helper(20,	size_mul, var++, 5);
673 	check_one_size_helper(20,	size_mul, 4, var++);
674 	check_one_size_helper(0,	size_mul, 0, 3);
675 	check_one_size_helper(0,	size_mul, 3, 0);
676 	check_one_size_helper(6,	size_mul, 2, 3);
677 	check_one_size_helper(SIZE_MAX,	size_mul, SIZE_MAX,  1);
678 	check_one_size_helper(SIZE_MAX,	size_mul, SIZE_MAX,  3);
679 	check_one_size_helper(SIZE_MAX,	size_mul, SIZE_MAX, -3);
680 
681 	var = 4;
682 	check_one_size_helper(9,	size_add, var++, 5);
683 	check_one_size_helper(9,	size_add, 4, var++);
684 	check_one_size_helper(9,	size_add, 9, 0);
685 	check_one_size_helper(9,	size_add, 0, 9);
686 	check_one_size_helper(5,	size_add, 2, 3);
687 	check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX,  1);
688 	check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX,  3);
689 	check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX, -3);
690 
691 	var = 4;
692 	check_one_size_helper(1,	size_sub, var--, 3);
693 	check_one_size_helper(1,	size_sub, 4, var--);
694 	check_one_size_helper(1,	size_sub, 3, 2);
695 	check_one_size_helper(9,	size_sub, 9, 0);
696 	check_one_size_helper(SIZE_MAX, size_sub, 9, -3);
697 	check_one_size_helper(SIZE_MAX, size_sub, 0, 9);
698 	check_one_size_helper(SIZE_MAX, size_sub, 2, 3);
699 	check_one_size_helper(SIZE_MAX, size_sub, SIZE_MAX,  0);
700 	check_one_size_helper(SIZE_MAX, size_sub, SIZE_MAX, 10);
701 	check_one_size_helper(SIZE_MAX, size_sub, 0,  SIZE_MAX);
702 	check_one_size_helper(SIZE_MAX, size_sub, 14, SIZE_MAX);
703 	check_one_size_helper(SIZE_MAX - 2, size_sub, SIZE_MAX - 1,  1);
704 	check_one_size_helper(SIZE_MAX - 4, size_sub, SIZE_MAX - 1,  3);
705 	check_one_size_helper(1,		size_sub, SIZE_MAX - 1, -3);
706 
707 	var = 4;
708 	check_one_size_helper(4 * sizeof(*obj->data),
709 			      flex_array_size, obj, data, var++);
710 	check_one_size_helper(5 * sizeof(*obj->data),
711 			      flex_array_size, obj, data, var++);
712 	check_one_size_helper(0, flex_array_size, obj, data, 0 + unconst);
713 	check_one_size_helper(sizeof(*obj->data),
714 			      flex_array_size, obj, data, 1 + unconst);
715 	check_one_size_helper(7 * sizeof(*obj->data),
716 			      flex_array_size, obj, data, 7 + unconst);
717 	check_one_size_helper(SIZE_MAX,
718 			      flex_array_size, obj, data, -1 + unconst);
719 	check_one_size_helper(SIZE_MAX,
720 			      flex_array_size, obj, data, SIZE_MAX - 4 + unconst);
721 
722 	var = 4;
723 	check_one_size_helper(sizeof(*obj) + (4 * sizeof(*obj->data)),
724 			      struct_size, obj, data, var++);
725 	check_one_size_helper(sizeof(*obj) + (5 * sizeof(*obj->data)),
726 			      struct_size, obj, data, var++);
727 	check_one_size_helper(sizeof(*obj), struct_size, obj, data, 0 + unconst);
728 	check_one_size_helper(sizeof(*obj) + sizeof(*obj->data),
729 			      struct_size, obj, data, 1 + unconst);
730 	check_one_size_helper(SIZE_MAX,
731 			      struct_size, obj, data, -3 + unconst);
732 	check_one_size_helper(SIZE_MAX,
733 			      struct_size, obj, data, SIZE_MAX - 3 + unconst);
734 
735 	kunit_info(test, "%d overflow size helper tests finished\n", count);
736 #undef check_one_size_helper
737 }
738 
739 static struct kunit_case overflow_test_cases[] = {
740 	KUNIT_CASE(u8_u8__u8_overflow_test),
741 	KUNIT_CASE(s8_s8__s8_overflow_test),
742 	KUNIT_CASE(u16_u16__u16_overflow_test),
743 	KUNIT_CASE(s16_s16__s16_overflow_test),
744 	KUNIT_CASE(u32_u32__u32_overflow_test),
745 	KUNIT_CASE(s32_s32__s32_overflow_test),
746 	KUNIT_CASE(u64_u64__u64_overflow_test),
747 	KUNIT_CASE(s64_s64__s64_overflow_test),
748 	KUNIT_CASE(u32_u32__int_overflow_test),
749 	KUNIT_CASE(u32_u32__u8_overflow_test),
750 	KUNIT_CASE(u8_u8__int_overflow_test),
751 	KUNIT_CASE(int_int__u8_overflow_test),
752 	KUNIT_CASE(shift_sane_test),
753 	KUNIT_CASE(shift_overflow_test),
754 	KUNIT_CASE(shift_truncate_test),
755 	KUNIT_CASE(shift_nonsense_test),
756 	KUNIT_CASE(overflow_allocation_test),
757 	KUNIT_CASE(overflow_size_helpers_test),
758 	{}
759 };
760 
761 static struct kunit_suite overflow_test_suite = {
762 	.name = "overflow",
763 	.test_cases = overflow_test_cases,
764 };
765 
766 kunit_test_suite(overflow_test_suite);
767 
768 MODULE_LICENSE("Dual MIT/GPL");
769