1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Test cases for sscanf facility.
4	*/
5
6	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8	#include <linux/bitops.h>
9	#include <linux/init.h>
10	#include <linux/kernel.h>
11	#include <linux/module.h>
12	#include <linux/overflow.h>
13	#include <linux/printk.h>
14	#include <linux/random.h>
15	#include <linux/slab.h>
16	#include <linux/string.h>
17
18	#include "../tools/testing/selftests/kselftest_module.h"
19
20	#define BUF_SIZE 1024
21
22	KSTM_MODULE_GLOBALS();
23	static char *test_buffer __initdata;
24	static char *fmt_buffer __initdata;
25	static struct rnd_state rnd_state __initdata;
26
27	typedef int (*check_fn)(const void *check_data, const char *string,
28	const char *fmt, int n_args, va_list ap);
29
30	static void __scanf(4, 6) __init
31	_test(check_fn fn, const void *check_data, const char *string, const char *fmt,
32	int n_args, ...)
33	{
34	va_list ap, ap_copy;
35	int ret;
36
37	total_tests++;
38
39	va_start(ap, n_args);
40	va_copy(ap_copy, ap);
41	ret = vsscanf(string, fmt, ap_copy);
42	va_end(ap_copy);
43
44	if (ret != n_args) {
45	pr_warn("vsscanf(\"%s\", \"%s\", ...) returned %d expected %d\n",
46	string, fmt, ret, n_args);
47	goto fail;
48	}
49
50	ret = (*fn)(check_data, string, fmt, n_args, ap);
51	if (ret)
52	goto fail;
53
54	va_end(ap);
55
56	return;
57
58	fail:
59	failed_tests++;
60	va_end(ap);
61	}
62
63	#define _check_numbers_template(arg_fmt, expect, str, fmt, n_args, ap) \
64	do { \
65	pr_debug("\"%s\", \"%s\" ->\n", str, fmt); \
66	for (; n_args > 0; n_args--, expect++) { \
67	typeof(*expect) got = *va_arg(ap, typeof(expect)); \
68	pr_debug("\t" arg_fmt "\n", got); \
69	if (got != *expect) { \
70	pr_warn("vsscanf(\"%s\", \"%s\", ...) expected " arg_fmt " got " arg_fmt "\n", \
71	str, fmt, *expect, got); \
72	return 1; \
73	} \
74	} \
75	return 0; \
76	} while (0)
77
78	static int __init check_ull(const void *check_data, const char *string,
79	const char *fmt, int n_args, va_list ap)
80	{
81	const unsigned long long *pval = check_data;
82
83	_check_numbers_template("%llu", pval, string, fmt, n_args, ap);
84	}
85
86	static int __init check_ll(const void *check_data, const char *string,
87	const char *fmt, int n_args, va_list ap)
88	{
89	const long long *pval = check_data;
90
91	_check_numbers_template("%lld", pval, string, fmt, n_args, ap);
92	}
93
94	static int __init check_ulong(const void *check_data, const char *string,
95	const char *fmt, int n_args, va_list ap)
96	{
97	const unsigned long *pval = check_data;
98
99	_check_numbers_template("%lu", pval, string, fmt, n_args, ap);
100	}
101
102	static int __init check_long(const void *check_data, const char *string,
103	const char *fmt, int n_args, va_list ap)
104	{
105	const long *pval = check_data;
106
107	_check_numbers_template("%ld", pval, string, fmt, n_args, ap);
108	}
109
110	static int __init check_uint(const void *check_data, const char *string,
111	const char *fmt, int n_args, va_list ap)
112	{
113	const unsigned int *pval = check_data;
114
115	_check_numbers_template("%u", pval, string, fmt, n_args, ap);
116	}
117
118	static int __init check_int(const void *check_data, const char *string,
119	const char *fmt, int n_args, va_list ap)
120	{
121	const int *pval = check_data;
122
123	_check_numbers_template("%d", pval, string, fmt, n_args, ap);
124	}
125
126	static int __init check_ushort(const void *check_data, const char *string,
127	const char *fmt, int n_args, va_list ap)
128	{
129	const unsigned short *pval = check_data;
130
131	_check_numbers_template("%hu", pval, string, fmt, n_args, ap);
132	}
133
134	static int __init check_short(const void *check_data, const char *string,
135	const char *fmt, int n_args, va_list ap)
136	{
137	const short *pval = check_data;
138
139	_check_numbers_template("%hd", pval, string, fmt, n_args, ap);
140	}
141
142	static int __init check_uchar(const void *check_data, const char *string,
143	const char *fmt, int n_args, va_list ap)
144	{
145	const unsigned char *pval = check_data;
146
147	_check_numbers_template("%hhu", pval, string, fmt, n_args, ap);
148	}
149
150	static int __init check_char(const void *check_data, const char *string,
151	const char *fmt, int n_args, va_list ap)
152	{
153	const signed char *pval = check_data;
154
155	_check_numbers_template("%hhd", pval, string, fmt, n_args, ap);
156	}
157
158	/* Selection of interesting numbers to test, copied from test-kstrtox.c */
159	static const unsigned long long numbers[] __initconst = {
160	0x0ULL,
161	0x1ULL,
162	0x7fULL,
163	0x80ULL,
164	0x81ULL,
165	0xffULL,
166	0x100ULL,
167	0x101ULL,
168	0x7fffULL,
169	0x8000ULL,
170	0x8001ULL,
171	0xffffULL,
172	0x10000ULL,
173	0x10001ULL,
174	0x7fffffffULL,
175	0x80000000ULL,
176	0x80000001ULL,
177	0xffffffffULL,
178	0x100000000ULL,
179	0x100000001ULL,
180	0x7fffffffffffffffULL,
181	0x8000000000000000ULL,
182	0x8000000000000001ULL,
183	0xfffffffffffffffeULL,
184	0xffffffffffffffffULL,
185	};
186
187	#define value_representable_in_type(T, val) \
188	(is_signed_type(T) \
189	? ((long long)(val) >= type_min(T)) && ((long long)(val) <= type_max(T)) \
190	: ((unsigned long long)(val) <= type_max(T)))
191
192
193	#define test_one_number(T, gen_fmt, scan_fmt, val, fn) \
194	do { \
195	const T expect_val = (T)(val); \
196	T result = ~expect_val; /* should be overwritten */ \
197	\
198	snprintf(test_buffer, BUF_SIZE, gen_fmt, expect_val); \
199	_test(fn, &expect_val, test_buffer, "%" scan_fmt, 1, &result); \
200	} while (0)
201
202	#define simple_numbers_loop(T, gen_fmt, scan_fmt, fn) \
203	do { \
204	int i; \
205	\
206	for (i = 0; i < ARRAY_SIZE(numbers); i++) { \
207	if (value_representable_in_type(T, numbers[i])) \
208	test_one_number(T, gen_fmt, scan_fmt, \
209	numbers[i], fn); \
210	\
211	if (value_representable_in_type(T, -numbers[i])) \
212	test_one_number(T, gen_fmt, scan_fmt, \
213	-numbers[i], fn); \
214	} \
215	} while (0)
216
217	static void __init numbers_simple(void)
218	{
219	simple_numbers_loop(unsigned long long, "%llu", "llu", check_ull);
220	simple_numbers_loop(long long, "%lld", "lld", check_ll);
221	simple_numbers_loop(long long, "%lld", "lli", check_ll);
222	simple_numbers_loop(unsigned long long, "%llx", "llx", check_ull);
223	simple_numbers_loop(long long, "%llx", "llx", check_ll);
224	simple_numbers_loop(long long, "0x%llx", "lli", check_ll);
225	simple_numbers_loop(unsigned long long, "0x%llx", "llx", check_ull);
226	simple_numbers_loop(long long, "0x%llx", "llx", check_ll);
227
228	simple_numbers_loop(unsigned long, "%lu", "lu", check_ulong);
229	simple_numbers_loop(long, "%ld", "ld", check_long);
230	simple_numbers_loop(long, "%ld", "li", check_long);
231	simple_numbers_loop(unsigned long, "%lx", "lx", check_ulong);
232	simple_numbers_loop(long, "%lx", "lx", check_long);
233	simple_numbers_loop(long, "0x%lx", "li", check_long);
234	simple_numbers_loop(unsigned long, "0x%lx", "lx", check_ulong);
235	simple_numbers_loop(long, "0x%lx", "lx", check_long);
236
237	simple_numbers_loop(unsigned int, "%u", "u", check_uint);
238	simple_numbers_loop(int, "%d", "d", check_int);
239	simple_numbers_loop(int, "%d", "i", check_int);
240	simple_numbers_loop(unsigned int, "%x", "x", check_uint);
241	simple_numbers_loop(int, "%x", "x", check_int);
242	simple_numbers_loop(int, "0x%x", "i", check_int);
243	simple_numbers_loop(unsigned int, "0x%x", "x", check_uint);
244	simple_numbers_loop(int, "0x%x", "x", check_int);
245
246	simple_numbers_loop(unsigned short, "%hu", "hu", check_ushort);
247	simple_numbers_loop(short, "%hd", "hd", check_short);
248	simple_numbers_loop(short, "%hd", "hi", check_short);
249	simple_numbers_loop(unsigned short, "%hx", "hx", check_ushort);
250	simple_numbers_loop(short, "%hx", "hx", check_short);
251	simple_numbers_loop(short, "0x%hx", "hi", check_short);
252	simple_numbers_loop(unsigned short, "0x%hx", "hx", check_ushort);
253	simple_numbers_loop(short, "0x%hx", "hx", check_short);
254
255	simple_numbers_loop(unsigned char, "%hhu", "hhu", check_uchar);
256	simple_numbers_loop(signed char, "%hhd", "hhd", check_char);
257	simple_numbers_loop(signed char, "%hhd", "hhi", check_char);
258	simple_numbers_loop(unsigned char, "%hhx", "hhx", check_uchar);
259	simple_numbers_loop(signed char, "%hhx", "hhx", check_char);
260	simple_numbers_loop(signed char, "0x%hhx", "hhi", check_char);
261	simple_numbers_loop(unsigned char, "0x%hhx", "hhx", check_uchar);
262	simple_numbers_loop(signed char, "0x%hhx", "hhx", check_char);
263	}
264
265	/*
266	* This gives a better variety of number "lengths" in a small sample than
267	* the raw prandom*() functions (Not mathematically rigorous!!).
268	* Variabilty of length and value is more important than perfect randomness.
269	*/
270	static u32 __init next_test_random(u32 max_bits)
271	{
272	u32 n_bits = hweight32(prandom_u32_state(&rnd_state)) % (max_bits + 1);
273
274	return prandom_u32_state(state: &rnd_state) & GENMASK(n_bits, 0);
275	}
276
277	static unsigned long long __init next_test_random_ull(void)
278	{
279	u32 rand1 = prandom_u32_state(state: &rnd_state);
280	u32 n_bits = (hweight32(rand1) * 3) % 64;
281	u64 val = (u64)prandom_u32_state(state: &rnd_state) * rand1;
282
283	return val & GENMASK_ULL(n_bits, 0);
284	}
285
286	#define random_for_type(T) \
287	((T)(sizeof(T) <= sizeof(u32) \
288	? next_test_random(BITS_PER_TYPE(T)) \
289	: next_test_random_ull()))
290
291	/*
292	* Define a pattern of negative and positive numbers to ensure we get
293	* some of both within the small number of samples in a test string.
294	*/
295	#define NEGATIVES_PATTERN 0x3246 /* 00110010 01000110 */
296
297	#define fill_random_array(arr) \
298	do { \
299	unsigned int neg_pattern = NEGATIVES_PATTERN; \
300	int i; \
301	\
302	for (i = 0; i < ARRAY_SIZE(arr); i++, neg_pattern >>= 1) { \
303	(arr)[i] = random_for_type(typeof((arr)[0])); \
304	if (is_signed_type(typeof((arr)[0])) && (neg_pattern & 1)) \
305	(arr)[i] = -(arr)[i]; \
306	} \
307	} while (0)
308
309	/*
310	* Convenience wrapper around snprintf() to append at buf_pos in buf,
311	* updating buf_pos and returning the number of characters appended.
312	* On error buf_pos is not changed and return value is 0.
313	*/
314	static int __init __printf(4, 5)
315	append_fmt(char *buf, int *buf_pos, int buf_len, const char *val_fmt, ...)
316	{
317	va_list ap;
318	int field_len;
319
320	va_start(ap, val_fmt);
321	field_len = vsnprintf(buf: buf + *buf_pos, size: buf_len - *buf_pos, fmt: val_fmt, args: ap);
322	va_end(ap);
323
324	if (field_len < 0)
325	field_len = 0;
326
327	*buf_pos += field_len;
328
329	return field_len;
330	}
331
332	/*
333	* Convenience function to append the field delimiter string
334	* to both the value string and format string buffers.
335	*/
336	static void __init append_delim(char *str_buf, int *str_buf_pos, int str_buf_len,
337	char *fmt_buf, int *fmt_buf_pos, int fmt_buf_len,
338	const char *delim_str)
339	{
340	append_fmt(buf: str_buf, buf_pos: str_buf_pos, buf_len: str_buf_len, val_fmt: delim_str);
341	append_fmt(buf: fmt_buf, buf_pos: fmt_buf_pos, buf_len: fmt_buf_len, val_fmt: delim_str);
342	}
343
344	#define test_array_8(fn, check_data, string, fmt, arr) \
345	do { \
346	BUILD_BUG_ON(ARRAY_SIZE(arr) != 8); \
347	_test(fn, check_data, string, fmt, 8, \
348	&(arr)[0], &(arr)[1], &(arr)[2], &(arr)[3], \
349	&(arr)[4], &(arr)[5], &(arr)[6], &(arr)[7]); \
350	} while (0)
351
352	#define numbers_list_8(T, gen_fmt, field_sep, scan_fmt, fn) \
353	do { \
354	int i, pos = 0, fmt_pos = 0; \
355	T expect[8], result[8]; \
356	\
357	fill_random_array(expect); \
358	\
359	for (i = 0; i < ARRAY_SIZE(expect); i++) { \
360	if (i != 0) \
361	append_delim(test_buffer, &pos, BUF_SIZE, \
362	fmt_buffer, &fmt_pos, BUF_SIZE, \
363	field_sep); \
364	\
365	append_fmt(test_buffer, &pos, BUF_SIZE, gen_fmt, expect[i]); \
366	append_fmt(fmt_buffer, &fmt_pos, BUF_SIZE, "%%%s", scan_fmt); \
367	} \
368	\
369	test_array_8(fn, expect, test_buffer, fmt_buffer, result); \
370	} while (0)
371
372	#define numbers_list_fix_width(T, gen_fmt, field_sep, width, scan_fmt, fn) \
373	do { \
374	char full_fmt[16]; \
375	\
376	snprintf(full_fmt, sizeof(full_fmt), "%u%s", width, scan_fmt); \
377	numbers_list_8(T, gen_fmt, field_sep, full_fmt, fn); \
378	} while (0)
379
380	#define numbers_list_val_width(T, gen_fmt, field_sep, scan_fmt, fn) \
381	do { \
382	int i, val_len, pos = 0, fmt_pos = 0; \
383	T expect[8], result[8]; \
384	\
385	fill_random_array(expect); \
386	\
387	for (i = 0; i < ARRAY_SIZE(expect); i++) { \
388	if (i != 0) \
389	append_delim(test_buffer, &pos, BUF_SIZE, \
390	fmt_buffer, &fmt_pos, BUF_SIZE, field_sep);\
391	\
392	val_len = append_fmt(test_buffer, &pos, BUF_SIZE, gen_fmt, \
393	expect[i]); \
394	append_fmt(fmt_buffer, &fmt_pos, BUF_SIZE, \
395	"%%%u%s", val_len, scan_fmt); \
396	} \
397	\
398	test_array_8(fn, expect, test_buffer, fmt_buffer, result); \
399	} while (0)
400
401	static void __init numbers_list_ll(const char *delim)
402	{
403	numbers_list_8(unsigned long long, "%llu", delim, "llu", check_ull);
404	numbers_list_8(long long, "%lld", delim, "lld", check_ll);
405	numbers_list_8(long long, "%lld", delim, "lli", check_ll);
406	numbers_list_8(unsigned long long, "%llx", delim, "llx", check_ull);
407	numbers_list_8(unsigned long long, "0x%llx", delim, "llx", check_ull);
408	numbers_list_8(long long, "0x%llx", delim, "lli", check_ll);
409	}
410
411	static void __init numbers_list_l(const char *delim)
412	{
413	numbers_list_8(unsigned long, "%lu", delim, "lu", check_ulong);
414	numbers_list_8(long, "%ld", delim, "ld", check_long);
415	numbers_list_8(long, "%ld", delim, "li", check_long);
416	numbers_list_8(unsigned long, "%lx", delim, "lx", check_ulong);
417	numbers_list_8(unsigned long, "0x%lx", delim, "lx", check_ulong);
418	numbers_list_8(long, "0x%lx", delim, "li", check_long);
419	}
420
421	static void __init numbers_list_d(const char *delim)
422	{
423	numbers_list_8(unsigned int, "%u", delim, "u", check_uint);
424	numbers_list_8(int, "%d", delim, "d", check_int);
425	numbers_list_8(int, "%d", delim, "i", check_int);
426	numbers_list_8(unsigned int, "%x", delim, "x", check_uint);
427	numbers_list_8(unsigned int, "0x%x", delim, "x", check_uint);
428	numbers_list_8(int, "0x%x", delim, "i", check_int);
429	}
430
431	static void __init numbers_list_h(const char *delim)
432	{
433	numbers_list_8(unsigned short, "%hu", delim, "hu", check_ushort);
434	numbers_list_8(short, "%hd", delim, "hd", check_short);
435	numbers_list_8(short, "%hd", delim, "hi", check_short);
436	numbers_list_8(unsigned short, "%hx", delim, "hx", check_ushort);
437	numbers_list_8(unsigned short, "0x%hx", delim, "hx", check_ushort);
438	numbers_list_8(short, "0x%hx", delim, "hi", check_short);
439	}
440
441	static void __init numbers_list_hh(const char *delim)
442	{
443	numbers_list_8(unsigned char, "%hhu", delim, "hhu", check_uchar);
444	numbers_list_8(signed char, "%hhd", delim, "hhd", check_char);
445	numbers_list_8(signed char, "%hhd", delim, "hhi", check_char);
446	numbers_list_8(unsigned char, "%hhx", delim, "hhx", check_uchar);
447	numbers_list_8(unsigned char, "0x%hhx", delim, "hhx", check_uchar);
448	numbers_list_8(signed char, "0x%hhx", delim, "hhi", check_char);
449	}
450
451	static void __init numbers_list(const char *delim)
452	{
453	numbers_list_ll(delim);
454	numbers_list_l(delim);
455	numbers_list_d(delim);
456	numbers_list_h(delim);
457	numbers_list_hh(delim);
458	}
459
460	static void __init numbers_list_field_width_ll(const char *delim)
461	{
462	numbers_list_fix_width(unsigned long long, "%llu", delim, 20, "llu", check_ull);
463	numbers_list_fix_width(long long, "%lld", delim, 20, "lld", check_ll);
464	numbers_list_fix_width(long long, "%lld", delim, 20, "lli", check_ll);
465	numbers_list_fix_width(unsigned long long, "%llx", delim, 16, "llx", check_ull);
466	numbers_list_fix_width(unsigned long long, "0x%llx", delim, 18, "llx", check_ull);
467	numbers_list_fix_width(long long, "0x%llx", delim, 18, "lli", check_ll);
468	}
469
470	static void __init numbers_list_field_width_l(const char *delim)
471	{
472	#if BITS_PER_LONG == 64
473	numbers_list_fix_width(unsigned long, "%lu", delim, 20, "lu", check_ulong);
474	numbers_list_fix_width(long, "%ld", delim, 20, "ld", check_long);
475	numbers_list_fix_width(long, "%ld", delim, 20, "li", check_long);
476	numbers_list_fix_width(unsigned long, "%lx", delim, 16, "lx", check_ulong);
477	numbers_list_fix_width(unsigned long, "0x%lx", delim, 18, "lx", check_ulong);
478	numbers_list_fix_width(long, "0x%lx", delim, 18, "li", check_long);
479	#else
480	numbers_list_fix_width(unsigned long, "%lu", delim, 10, "lu", check_ulong);
481	numbers_list_fix_width(long, "%ld", delim, 11, "ld", check_long);
482	numbers_list_fix_width(long, "%ld", delim, 11, "li", check_long);
483	numbers_list_fix_width(unsigned long, "%lx", delim, 8, "lx", check_ulong);
484	numbers_list_fix_width(unsigned long, "0x%lx", delim, 10, "lx", check_ulong);
485	numbers_list_fix_width(long, "0x%lx", delim, 10, "li", check_long);
486	#endif
487	}
488
489	static void __init numbers_list_field_width_d(const char *delim)
490	{
491	numbers_list_fix_width(unsigned int, "%u", delim, 10, "u", check_uint);
492	numbers_list_fix_width(int, "%d", delim, 11, "d", check_int);
493	numbers_list_fix_width(int, "%d", delim, 11, "i", check_int);
494	numbers_list_fix_width(unsigned int, "%x", delim, 8, "x", check_uint);
495	numbers_list_fix_width(unsigned int, "0x%x", delim, 10, "x", check_uint);
496	numbers_list_fix_width(int, "0x%x", delim, 10, "i", check_int);
497	}
498
499	static void __init numbers_list_field_width_h(const char *delim)
500	{
501	numbers_list_fix_width(unsigned short, "%hu", delim, 5, "hu", check_ushort);
502	numbers_list_fix_width(short, "%hd", delim, 6, "hd", check_short);
503	numbers_list_fix_width(short, "%hd", delim, 6, "hi", check_short);
504	numbers_list_fix_width(unsigned short, "%hx", delim, 4, "hx", check_ushort);
505	numbers_list_fix_width(unsigned short, "0x%hx", delim, 6, "hx", check_ushort);
506	numbers_list_fix_width(short, "0x%hx", delim, 6, "hi", check_short);
507	}
508
509	static void __init numbers_list_field_width_hh(const char *delim)
510	{
511	numbers_list_fix_width(unsigned char, "%hhu", delim, 3, "hhu", check_uchar);
512	numbers_list_fix_width(signed char, "%hhd", delim, 4, "hhd", check_char);
513	numbers_list_fix_width(signed char, "%hhd", delim, 4, "hhi", check_char);
514	numbers_list_fix_width(unsigned char, "%hhx", delim, 2, "hhx", check_uchar);
515	numbers_list_fix_width(unsigned char, "0x%hhx", delim, 4, "hhx", check_uchar);
516	numbers_list_fix_width(signed char, "0x%hhx", delim, 4, "hhi", check_char);
517	}
518
519	/*
520	* List of numbers separated by delim. Each field width specifier is the
521	* maximum possible digits for the given type and base.
522	*/
523	static void __init numbers_list_field_width_typemax(const char *delim)
524	{
525	numbers_list_field_width_ll(delim);
526	numbers_list_field_width_l(delim);
527	numbers_list_field_width_d(delim);
528	numbers_list_field_width_h(delim);
529	numbers_list_field_width_hh(delim);
530	}
531
532	static void __init numbers_list_field_width_val_ll(const char *delim)
533	{
534	numbers_list_val_width(unsigned long long, "%llu", delim, "llu", check_ull);
535	numbers_list_val_width(long long, "%lld", delim, "lld", check_ll);
536	numbers_list_val_width(long long, "%lld", delim, "lli", check_ll);
537	numbers_list_val_width(unsigned long long, "%llx", delim, "llx", check_ull);
538	numbers_list_val_width(unsigned long long, "0x%llx", delim, "llx", check_ull);
539	numbers_list_val_width(long long, "0x%llx", delim, "lli", check_ll);
540	}
541
542	static void __init numbers_list_field_width_val_l(const char *delim)
543	{
544	numbers_list_val_width(unsigned long, "%lu", delim, "lu", check_ulong);
545	numbers_list_val_width(long, "%ld", delim, "ld", check_long);
546	numbers_list_val_width(long, "%ld", delim, "li", check_long);
547	numbers_list_val_width(unsigned long, "%lx", delim, "lx", check_ulong);
548	numbers_list_val_width(unsigned long, "0x%lx", delim, "lx", check_ulong);
549	numbers_list_val_width(long, "0x%lx", delim, "li", check_long);
550	}
551
552	static void __init numbers_list_field_width_val_d(const char *delim)
553	{
554	numbers_list_val_width(unsigned int, "%u", delim, "u", check_uint);
555	numbers_list_val_width(int, "%d", delim, "d", check_int);
556	numbers_list_val_width(int, "%d", delim, "i", check_int);
557	numbers_list_val_width(unsigned int, "%x", delim, "x", check_uint);
558	numbers_list_val_width(unsigned int, "0x%x", delim, "x", check_uint);
559	numbers_list_val_width(int, "0x%x", delim, "i", check_int);
560	}
561
562	static void __init numbers_list_field_width_val_h(const char *delim)
563	{
564	numbers_list_val_width(unsigned short, "%hu", delim, "hu", check_ushort);
565	numbers_list_val_width(short, "%hd", delim, "hd", check_short);
566	numbers_list_val_width(short, "%hd", delim, "hi", check_short);
567	numbers_list_val_width(unsigned short, "%hx", delim, "hx", check_ushort);
568	numbers_list_val_width(unsigned short, "0x%hx", delim, "hx", check_ushort);
569	numbers_list_val_width(short, "0x%hx", delim, "hi", check_short);
570	}
571
572	static void __init numbers_list_field_width_val_hh(const char *delim)
573	{
574	numbers_list_val_width(unsigned char, "%hhu", delim, "hhu", check_uchar);
575	numbers_list_val_width(signed char, "%hhd", delim, "hhd", check_char);
576	numbers_list_val_width(signed char, "%hhd", delim, "hhi", check_char);
577	numbers_list_val_width(unsigned char, "%hhx", delim, "hhx", check_uchar);
578	numbers_list_val_width(unsigned char, "0x%hhx", delim, "hhx", check_uchar);
579	numbers_list_val_width(signed char, "0x%hhx", delim, "hhi", check_char);
580	}
581
582	/*
583	* List of numbers separated by delim. Each field width specifier is the
584	* exact length of the corresponding value digits in the string being scanned.
585	*/
586	static void __init numbers_list_field_width_val_width(const char *delim)
587	{
588	numbers_list_field_width_val_ll(delim);
589	numbers_list_field_width_val_l(delim);
590	numbers_list_field_width_val_d(delim);
591	numbers_list_field_width_val_h(delim);
592	numbers_list_field_width_val_hh(delim);
593	}
594
595	/*
596	* Slice a continuous string of digits without field delimiters, containing
597	* numbers of varying length, using the field width to extract each group
598	* of digits. For example the hex values c0,3,bf01,303 would have a
599	* string representation of "c03bf01303" and extracted with "%2x%1x%4x%3x".
600	*/
601	static void __init numbers_slice(void)
602	{
603	numbers_list_field_width_val_width(delim: "");
604	}
605
606	#define test_number_prefix(T, str, scan_fmt, expect0, expect1, n_args, fn) \
607	do { \
608	const T expect[2] = { expect0, expect1 }; \
609	T result[2] = { (T)~expect[0], (T)~expect[1] }; \
610	\
611	_test(fn, &expect, str, scan_fmt, n_args, &result[0], &result[1]); \
612	} while (0)
613
614	/*
615	* Number prefix is >= field width.
616	* Expected behaviour is derived from testing userland sscanf.
617	*/
618	static void __init numbers_prefix_overflow(void)
619	{
620	/*
621	* Negative decimal with a field of width 1, should quit scanning
622	* and return 0.
623	*/
624	test_number_prefix(long long, "-1 1", "%1lld %lld", 0, 0, 0, check_ll);
625	test_number_prefix(long, "-1 1", "%1ld %ld", 0, 0, 0, check_long);
626	test_number_prefix(int, "-1 1", "%1d %d", 0, 0, 0, check_int);
627	test_number_prefix(short, "-1 1", "%1hd %hd", 0, 0, 0, check_short);
628	test_number_prefix(signed char, "-1 1", "%1hhd %hhd", 0, 0, 0, check_char);
629
630	test_number_prefix(long long, "-1 1", "%1lli %lli", 0, 0, 0, check_ll);
631	test_number_prefix(long, "-1 1", "%1li %li", 0, 0, 0, check_long);
632	test_number_prefix(int, "-1 1", "%1i %i", 0, 0, 0, check_int);
633	test_number_prefix(short, "-1 1", "%1hi %hi", 0, 0, 0, check_short);
634	test_number_prefix(signed char, "-1 1", "%1hhi %hhi", 0, 0, 0, check_char);
635
636	/*
637	* 0x prefix in a field of width 1: 0 is a valid digit so should
638	* convert. Next field scan starts at the 'x' which isn't a digit so
639	* scan quits with one field converted.
640	*/
641	test_number_prefix(unsigned long long, "0xA7", "%1llx%llx", 0, 0, 1, check_ull);
642	test_number_prefix(unsigned long, "0xA7", "%1lx%lx", 0, 0, 1, check_ulong);
643	test_number_prefix(unsigned int, "0xA7", "%1x%x", 0, 0, 1, check_uint);
644	test_number_prefix(unsigned short, "0xA7", "%1hx%hx", 0, 0, 1, check_ushort);
645	test_number_prefix(unsigned char, "0xA7", "%1hhx%hhx", 0, 0, 1, check_uchar);
646	test_number_prefix(long long, "0xA7", "%1lli%llx", 0, 0, 1, check_ll);
647	test_number_prefix(long, "0xA7", "%1li%lx", 0, 0, 1, check_long);
648	test_number_prefix(int, "0xA7", "%1i%x", 0, 0, 1, check_int);
649	test_number_prefix(short, "0xA7", "%1hi%hx", 0, 0, 1, check_short);
650	test_number_prefix(char, "0xA7", "%1hhi%hhx", 0, 0, 1, check_char);
651
652	/*
653	* 0x prefix in a field of width 2 using %x conversion: first field
654	* converts to 0. Next field scan starts at the character after "0x".
655	* Both fields will convert.
656	*/
657	test_number_prefix(unsigned long long, "0xA7", "%2llx%llx", 0, 0xa7, 2, check_ull);
658	test_number_prefix(unsigned long, "0xA7", "%2lx%lx", 0, 0xa7, 2, check_ulong);
659	test_number_prefix(unsigned int, "0xA7", "%2x%x", 0, 0xa7, 2, check_uint);
660	test_number_prefix(unsigned short, "0xA7", "%2hx%hx", 0, 0xa7, 2, check_ushort);
661	test_number_prefix(unsigned char, "0xA7", "%2hhx%hhx", 0, 0xa7, 2, check_uchar);
662
663	/*
664	* 0x prefix in a field of width 2 using %i conversion: first field
665	* converts to 0. Next field scan starts at the character after "0x",
666	* which will convert if can be interpreted as decimal but will fail
667	* if it contains any hex digits (since no 0x prefix).
668	*/
669	test_number_prefix(long long, "0x67", "%2lli%lli", 0, 67, 2, check_ll);
670	test_number_prefix(long, "0x67", "%2li%li", 0, 67, 2, check_long);
671	test_number_prefix(int, "0x67", "%2i%i", 0, 67, 2, check_int);
672	test_number_prefix(short, "0x67", "%2hi%hi", 0, 67, 2, check_short);
673	test_number_prefix(char, "0x67", "%2hhi%hhi", 0, 67, 2, check_char);
674
675	test_number_prefix(long long, "0xA7", "%2lli%lli", 0, 0, 1, check_ll);
676	test_number_prefix(long, "0xA7", "%2li%li", 0, 0, 1, check_long);
677	test_number_prefix(int, "0xA7", "%2i%i", 0, 0, 1, check_int);
678	test_number_prefix(short, "0xA7", "%2hi%hi", 0, 0, 1, check_short);
679	test_number_prefix(char, "0xA7", "%2hhi%hhi", 0, 0, 1, check_char);
680	}
681
682	#define _test_simple_strtoxx(T, fn, gen_fmt, expect, base) \
683	do { \
684	T got; \
685	char *endp; \
686	int len; \
687	bool fail = false; \
688	\
689	total_tests++; \
690	len = snprintf(test_buffer, BUF_SIZE, gen_fmt, expect); \
691	got = (fn)(test_buffer, &endp, base); \
692	pr_debug(#fn "(\"%s\", %d) -> " gen_fmt "\n", test_buffer, base, got); \
693	if (got != (expect)) { \
694	fail = true; \
695	pr_warn(#fn "(\"%s\", %d): got " gen_fmt " expected " gen_fmt "\n", \
696	test_buffer, base, got, expect); \
697	} else if (endp != test_buffer + len) { \
698	fail = true; \
699	pr_warn(#fn "(\"%s\", %d) startp=0x%px got endp=0x%px expected 0x%px\n", \
700	test_buffer, base, test_buffer, \
701	test_buffer + len, endp); \
702	} \
703	\
704	if (fail) \
705	failed_tests++; \
706	} while (0)
707
708	#define test_simple_strtoxx(T, fn, gen_fmt, base) \
709	do { \
710	int i; \
711	\
712	for (i = 0; i < ARRAY_SIZE(numbers); i++) { \
713	_test_simple_strtoxx(T, fn, gen_fmt, (T)numbers[i], base); \
714	\
715	if (is_signed_type(T)) \
716	_test_simple_strtoxx(T, fn, gen_fmt, \
717	-(T)numbers[i], base); \
718	} \
719	} while (0)
720
721	static void __init test_simple_strtoull(void)
722	{
723	test_simple_strtoxx(unsigned long long, simple_strtoull, "%llu", 10);
724	test_simple_strtoxx(unsigned long long, simple_strtoull, "%llu", 0);
725	test_simple_strtoxx(unsigned long long, simple_strtoull, "%llx", 16);
726	test_simple_strtoxx(unsigned long long, simple_strtoull, "0x%llx", 16);
727	test_simple_strtoxx(unsigned long long, simple_strtoull, "0x%llx", 0);
728	}
729
730	static void __init test_simple_strtoll(void)
731	{
732	test_simple_strtoxx(long long, simple_strtoll, "%lld", 10);
733	test_simple_strtoxx(long long, simple_strtoll, "%lld", 0);
734	test_simple_strtoxx(long long, simple_strtoll, "%llx", 16);
735	test_simple_strtoxx(long long, simple_strtoll, "0x%llx", 16);
736	test_simple_strtoxx(long long, simple_strtoll, "0x%llx", 0);
737	}
738
739	static void __init test_simple_strtoul(void)
740	{
741	test_simple_strtoxx(unsigned long, simple_strtoul, "%lu", 10);
742	test_simple_strtoxx(unsigned long, simple_strtoul, "%lu", 0);
743	test_simple_strtoxx(unsigned long, simple_strtoul, "%lx", 16);
744	test_simple_strtoxx(unsigned long, simple_strtoul, "0x%lx", 16);
745	test_simple_strtoxx(unsigned long, simple_strtoul, "0x%lx", 0);
746	}
747
748	static void __init test_simple_strtol(void)
749	{
750	test_simple_strtoxx(long, simple_strtol, "%ld", 10);
751	test_simple_strtoxx(long, simple_strtol, "%ld", 0);
752	test_simple_strtoxx(long, simple_strtol, "%lx", 16);
753	test_simple_strtoxx(long, simple_strtol, "0x%lx", 16);
754	test_simple_strtoxx(long, simple_strtol, "0x%lx", 0);
755	}
756
757	/* Selection of common delimiters/separators between numbers in a string. */
758	static const char * const number_delimiters[] __initconst = {
759	" ", ":", ",", "-", "/",
760	};
761
762	static void __init test_numbers(void)
763	{
764	int i;
765
766	/* String containing only one number. */
767	numbers_simple();
768
769	/* String with multiple numbers separated by delimiter. */
770	for (i = 0; i < ARRAY_SIZE(number_delimiters); i++) {
771	numbers_list(delim: number_delimiters[i]);
772
773	/* Field width may be longer than actual field digits. */
774	numbers_list_field_width_typemax(delim: number_delimiters[i]);
775
776	/* Each field width exactly length of actual field digits. */
777	numbers_list_field_width_val_width(delim: number_delimiters[i]);
778	}
779
780	/* Slice continuous sequence of digits using field widths. */
781	numbers_slice();
782
783	numbers_prefix_overflow();
784	}
785
786	static void __init selftest(void)
787	{
788	test_buffer = kmalloc(BUF_SIZE, GFP_KERNEL);
789	if (!test_buffer)
790	return;
791
792	fmt_buffer = kmalloc(BUF_SIZE, GFP_KERNEL);
793	if (!fmt_buffer) {
794	kfree(objp: test_buffer);
795	return;
796	}
797
798	prandom_seed_state(state: &rnd_state, seed: 3141592653589793238ULL);
799
800	test_numbers();
801
802	test_simple_strtoull();
803	test_simple_strtoll();
804	test_simple_strtoul();
805	test_simple_strtol();
806
807	kfree(objp: fmt_buffer);
808	kfree(objp: test_buffer);
809	}
810
811	KSTM_MODULE_LOADERS(test_scanf);
812	MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
813	MODULE_LICENSE("GPL v2");
814