1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Test cases for printf facility.
4 */
5
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8 #include <linux/init.h>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/printk.h>
12 #include <linux/random.h>
13 #include <linux/rtc.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16
17 #include <linux/bitmap.h>
18 #include <linux/dcache.h>
19 #include <linux/socket.h>
20 #include <linux/in.h>
21
22 #include <linux/gfp.h>
23 #include <linux/mm.h>
24
25 #include "../tools/testing/selftests/kselftest_module.h"
26
27 #define BUF_SIZE 256
28 #define PAD_SIZE 16
29 #define FILL_CHAR '$'
30
31 static unsigned total_tests __initdata;
32 static unsigned failed_tests __initdata;
33 static char *test_buffer __initdata;
34 static char *alloced_buffer __initdata;
35
36 static int __printf(4, 0) __init
do_test(int bufsize,const char * expect,int elen,const char * fmt,va_list ap)37 do_test(int bufsize, const char *expect, int elen,
38 const char *fmt, va_list ap)
39 {
40 va_list aq;
41 int ret, written;
42
43 total_tests++;
44
45 memset(alloced_buffer, FILL_CHAR, BUF_SIZE + 2*PAD_SIZE);
46 va_copy(aq, ap);
47 ret = vsnprintf(test_buffer, bufsize, fmt, aq);
48 va_end(aq);
49
50 if (ret != elen) {
51 pr_warn("vsnprintf(buf, %d, \"%s\", ...) returned %d, expected %d\n",
52 bufsize, fmt, ret, elen);
53 return 1;
54 }
55
56 if (memchr_inv(alloced_buffer, FILL_CHAR, PAD_SIZE)) {
57 pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote before buffer\n", bufsize, fmt);
58 return 1;
59 }
60
61 if (!bufsize) {
62 if (memchr_inv(test_buffer, FILL_CHAR, BUF_SIZE + PAD_SIZE)) {
63 pr_warn("vsnprintf(buf, 0, \"%s\", ...) wrote to buffer\n",
64 fmt);
65 return 1;
66 }
67 return 0;
68 }
69
70 written = min(bufsize-1, elen);
71 if (test_buffer[written]) {
72 pr_warn("vsnprintf(buf, %d, \"%s\", ...) did not nul-terminate buffer\n",
73 bufsize, fmt);
74 return 1;
75 }
76
77 if (memchr_inv(test_buffer + written + 1, FILL_CHAR, BUF_SIZE + PAD_SIZE - (written + 1))) {
78 pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote beyond the nul-terminator\n",
79 bufsize, fmt);
80 return 1;
81 }
82
83 if (memcmp(test_buffer, expect, written)) {
84 pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote '%s', expected '%.*s'\n",
85 bufsize, fmt, test_buffer, written, expect);
86 return 1;
87 }
88 return 0;
89 }
90
91 static void __printf(3, 4) __init
__test(const char * expect,int elen,const char * fmt,...)92 __test(const char *expect, int elen, const char *fmt, ...)
93 {
94 va_list ap;
95 int rand;
96 char *p;
97
98 if (elen >= BUF_SIZE) {
99 pr_err("error in test suite: expected output length %d too long. Format was '%s'.\n",
100 elen, fmt);
101 failed_tests++;
102 return;
103 }
104
105 va_start(ap, fmt);
106
107 /*
108 * Every fmt+args is subjected to four tests: Three where we
109 * tell vsnprintf varying buffer sizes (plenty, not quite
110 * enough and 0), and then we also test that kvasprintf would
111 * be able to print it as expected.
112 */
113 failed_tests += do_test(BUF_SIZE, expect, elen, fmt, ap);
114 rand = 1 + prandom_u32_max(elen+1);
115 /* Since elen < BUF_SIZE, we have 1 <= rand <= BUF_SIZE. */
116 failed_tests += do_test(rand, expect, elen, fmt, ap);
117 failed_tests += do_test(0, expect, elen, fmt, ap);
118
119 p = kvasprintf(GFP_KERNEL, fmt, ap);
120 if (p) {
121 total_tests++;
122 if (memcmp(p, expect, elen+1)) {
123 pr_warn("kvasprintf(..., \"%s\", ...) returned '%s', expected '%s'\n",
124 fmt, p, expect);
125 failed_tests++;
126 }
127 kfree(p);
128 }
129 va_end(ap);
130 }
131
132 #define test(expect, fmt, ...) \
133 __test(expect, strlen(expect), fmt, ##__VA_ARGS__)
134
135 static void __init
test_basic(void)136 test_basic(void)
137 {
138 /* Work around annoying "warning: zero-length gnu_printf format string". */
139 char nul = '\0';
140
141 test("", &nul);
142 test("100%", "100%%");
143 test("xxx%yyy", "xxx%cyyy", '%');
144 __test("xxx\0yyy", 7, "xxx%cyyy", '\0');
145 }
146
147 static void __init
test_number(void)148 test_number(void)
149 {
150 test("0x1234abcd ", "%#-12x", 0x1234abcd);
151 test(" 0x1234abcd", "%#12x", 0x1234abcd);
152 test("0|001| 12|+123| 1234|-123|-1234", "%d|%03d|%3d|%+d|% d|%+d|% d", 0, 1, 12, 123, 1234, -123, -1234);
153 test("0|1|1|128|255", "%hhu|%hhu|%hhu|%hhu|%hhu", 0, 1, 257, 128, -1);
154 test("0|1|1|-128|-1", "%hhd|%hhd|%hhd|%hhd|%hhd", 0, 1, 257, 128, -1);
155 test("2015122420151225", "%ho%ho%#ho", 1037, 5282, -11627);
156 /*
157 * POSIX/C99: »The result of converting zero with an explicit
158 * precision of zero shall be no characters.« Hence the output
159 * from the below test should really be "00|0||| ". However,
160 * the kernel's printf also produces a single 0 in that
161 * case. This test case simply documents the current
162 * behaviour.
163 */
164 test("00|0|0|0|0", "%.2d|%.1d|%.0d|%.*d|%1.0d", 0, 0, 0, 0, 0, 0);
165 #ifndef __CHAR_UNSIGNED__
166 {
167 /*
168 * Passing a 'char' to a %02x specifier doesn't do
169 * what was presumably the intention when char is
170 * signed and the value is negative. One must either &
171 * with 0xff or cast to u8.
172 */
173 char val = -16;
174 test("0xfffffff0|0xf0|0xf0", "%#02x|%#02x|%#02x", val, val & 0xff, (u8)val);
175 }
176 #endif
177 }
178
179 static void __init
test_string(void)180 test_string(void)
181 {
182 test("", "%s%.0s", "", "123");
183 test("ABCD|abc|123", "%s|%.3s|%.*s", "ABCD", "abcdef", 3, "123456");
184 test("1 | 2|3 | 4|5 ", "%-3s|%3s|%-*s|%*s|%*s", "1", "2", 3, "3", 3, "4", -3, "5");
185 test("1234 ", "%-10.4s", "123456");
186 test(" 1234", "%10.4s", "123456");
187 /*
188 * POSIX and C99 say that a negative precision (which is only
189 * possible to pass via a * argument) should be treated as if
190 * the precision wasn't present, and that if the precision is
191 * omitted (as in %.s), the precision should be taken to be
192 * 0. However, the kernel's printf behave exactly opposite,
193 * treating a negative precision as 0 and treating an omitted
194 * precision specifier as if no precision was given.
195 *
196 * These test cases document the current behaviour; should
197 * anyone ever feel the need to follow the standards more
198 * closely, this can be revisited.
199 */
200 test(" ", "%4.*s", -5, "123456");
201 test("123456", "%.s", "123456");
202 test("a||", "%.s|%.0s|%.*s", "a", "b", 0, "c");
203 test("a | | ", "%-3.s|%-3.0s|%-3.*s", "a", "b", 0, "c");
204 }
205
206 #define PLAIN_BUF_SIZE 64 /* leave some space so we don't oops */
207
208 #if BITS_PER_LONG == 64
209
210 #define PTR_WIDTH 16
211 #define PTR ((void *)0xffff0123456789abUL)
212 #define PTR_STR "ffff0123456789ab"
213 #define PTR_VAL_NO_CRNG "(____ptrval____)"
214 #define ZEROS "00000000" /* hex 32 zero bits */
215
216 static int __init
plain_format(void)217 plain_format(void)
218 {
219 char buf[PLAIN_BUF_SIZE];
220 int nchars;
221
222 nchars = snprintf(buf, PLAIN_BUF_SIZE, "%p", PTR);
223
224 if (nchars != PTR_WIDTH)
225 return -1;
226
227 if (strncmp(buf, PTR_VAL_NO_CRNG, PTR_WIDTH) == 0) {
228 pr_warn("crng possibly not yet initialized. plain 'p' buffer contains \"%s\"",
229 PTR_VAL_NO_CRNG);
230 return 0;
231 }
232
233 if (strncmp(buf, ZEROS, strlen(ZEROS)) != 0)
234 return -1;
235
236 return 0;
237 }
238
239 #else
240
241 #define PTR_WIDTH 8
242 #define PTR ((void *)0x456789ab)
243 #define PTR_STR "456789ab"
244 #define PTR_VAL_NO_CRNG "(ptrval)"
245 #define ZEROS ""
246
247 static int __init
plain_format(void)248 plain_format(void)
249 {
250 /* Format is implicitly tested for 32 bit machines by plain_hash() */
251 return 0;
252 }
253
254 #endif /* BITS_PER_LONG == 64 */
255
256 static int __init
plain_hash_to_buffer(const void * p,char * buf,size_t len)257 plain_hash_to_buffer(const void *p, char *buf, size_t len)
258 {
259 int nchars;
260
261 nchars = snprintf(buf, len, "%p", p);
262
263 if (nchars != PTR_WIDTH)
264 return -1;
265
266 if (strncmp(buf, PTR_VAL_NO_CRNG, PTR_WIDTH) == 0) {
267 pr_warn("crng possibly not yet initialized. plain 'p' buffer contains \"%s\"",
268 PTR_VAL_NO_CRNG);
269 return 0;
270 }
271
272 return 0;
273 }
274
275 static int __init
plain_hash(void)276 plain_hash(void)
277 {
278 char buf[PLAIN_BUF_SIZE];
279 int ret;
280
281 ret = plain_hash_to_buffer(PTR, buf, PLAIN_BUF_SIZE);
282 if (ret)
283 return ret;
284
285 if (strncmp(buf, PTR_STR, PTR_WIDTH) == 0)
286 return -1;
287
288 return 0;
289 }
290
291 /*
292 * We can't use test() to test %p because we don't know what output to expect
293 * after an address is hashed.
294 */
295 static void __init
plain(void)296 plain(void)
297 {
298 int err;
299
300 err = plain_hash();
301 if (err) {
302 pr_warn("plain 'p' does not appear to be hashed\n");
303 failed_tests++;
304 return;
305 }
306
307 err = plain_format();
308 if (err) {
309 pr_warn("hashing plain 'p' has unexpected format\n");
310 failed_tests++;
311 }
312 }
313
314 static void __init
test_hashed(const char * fmt,const void * p)315 test_hashed(const char *fmt, const void *p)
316 {
317 char buf[PLAIN_BUF_SIZE];
318 int ret;
319
320 /*
321 * No need to increase failed test counter since this is assumed
322 * to be called after plain().
323 */
324 ret = plain_hash_to_buffer(p, buf, PLAIN_BUF_SIZE);
325 if (ret)
326 return;
327
328 test(buf, fmt, p);
329 }
330
331 static void __init
null_pointer(void)332 null_pointer(void)
333 {
334 test_hashed("%p", NULL);
335 test(ZEROS "00000000", "%px", NULL);
336 test("(null)", "%pE", NULL);
337 }
338
339 #define PTR_INVALID ((void *)0x000000ab)
340
341 static void __init
invalid_pointer(void)342 invalid_pointer(void)
343 {
344 test_hashed("%p", PTR_INVALID);
345 test(ZEROS "000000ab", "%px", PTR_INVALID);
346 test("(efault)", "%pE", PTR_INVALID);
347 }
348
349 static void __init
symbol_ptr(void)350 symbol_ptr(void)
351 {
352 }
353
354 static void __init
kernel_ptr(void)355 kernel_ptr(void)
356 {
357 /* We can't test this without access to kptr_restrict. */
358 }
359
360 static void __init
struct_resource(void)361 struct_resource(void)
362 {
363 }
364
365 static void __init
addr(void)366 addr(void)
367 {
368 }
369
370 static void __init
escaped_str(void)371 escaped_str(void)
372 {
373 }
374
375 static void __init
hex_string(void)376 hex_string(void)
377 {
378 const char buf[3] = {0xc0, 0xff, 0xee};
379
380 test("c0 ff ee|c0:ff:ee|c0-ff-ee|c0ffee",
381 "%3ph|%3phC|%3phD|%3phN", buf, buf, buf, buf);
382 test("c0 ff ee|c0:ff:ee|c0-ff-ee|c0ffee",
383 "%*ph|%*phC|%*phD|%*phN", 3, buf, 3, buf, 3, buf, 3, buf);
384 }
385
386 static void __init
mac(void)387 mac(void)
388 {
389 const u8 addr[6] = {0x2d, 0x48, 0xd6, 0xfc, 0x7a, 0x05};
390
391 test("2d:48:d6:fc:7a:05", "%pM", addr);
392 test("05:7a:fc:d6:48:2d", "%pMR", addr);
393 test("2d-48-d6-fc-7a-05", "%pMF", addr);
394 test("2d48d6fc7a05", "%pm", addr);
395 test("057afcd6482d", "%pmR", addr);
396 }
397
398 static void __init
ip4(void)399 ip4(void)
400 {
401 struct sockaddr_in sa;
402
403 sa.sin_family = AF_INET;
404 sa.sin_port = cpu_to_be16(12345);
405 sa.sin_addr.s_addr = cpu_to_be32(0x7f000001);
406
407 test("127.000.000.001|127.0.0.1", "%pi4|%pI4", &sa.sin_addr, &sa.sin_addr);
408 test("127.000.000.001|127.0.0.1", "%piS|%pIS", &sa, &sa);
409 sa.sin_addr.s_addr = cpu_to_be32(0x01020304);
410 test("001.002.003.004:12345|1.2.3.4:12345", "%piSp|%pISp", &sa, &sa);
411 }
412
413 static void __init
ip6(void)414 ip6(void)
415 {
416 }
417
418 static void __init
ip(void)419 ip(void)
420 {
421 ip4();
422 ip6();
423 }
424
425 static void __init
uuid(void)426 uuid(void)
427 {
428 const char uuid[16] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
429 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
430
431 test("00010203-0405-0607-0809-0a0b0c0d0e0f", "%pUb", uuid);
432 test("00010203-0405-0607-0809-0A0B0C0D0E0F", "%pUB", uuid);
433 test("03020100-0504-0706-0809-0a0b0c0d0e0f", "%pUl", uuid);
434 test("03020100-0504-0706-0809-0A0B0C0D0E0F", "%pUL", uuid);
435 }
436
437 static struct dentry test_dentry[4] __initdata = {
438 { .d_parent = &test_dentry[0],
439 .d_name = QSTR_INIT(test_dentry[0].d_iname, 3),
440 .d_iname = "foo" },
441 { .d_parent = &test_dentry[0],
442 .d_name = QSTR_INIT(test_dentry[1].d_iname, 5),
443 .d_iname = "bravo" },
444 { .d_parent = &test_dentry[1],
445 .d_name = QSTR_INIT(test_dentry[2].d_iname, 4),
446 .d_iname = "alfa" },
447 { .d_parent = &test_dentry[2],
448 .d_name = QSTR_INIT(test_dentry[3].d_iname, 5),
449 .d_iname = "romeo" },
450 };
451
452 static void __init
dentry(void)453 dentry(void)
454 {
455 test("foo", "%pd", &test_dentry[0]);
456 test("foo", "%pd2", &test_dentry[0]);
457
458 test("(null)", "%pd", NULL);
459 test("(efault)", "%pd", PTR_INVALID);
460 test("(null)", "%pD", NULL);
461 test("(efault)", "%pD", PTR_INVALID);
462
463 test("romeo", "%pd", &test_dentry[3]);
464 test("alfa/romeo", "%pd2", &test_dentry[3]);
465 test("bravo/alfa/romeo", "%pd3", &test_dentry[3]);
466 test("/bravo/alfa/romeo", "%pd4", &test_dentry[3]);
467 test("/bravo/alfa", "%pd4", &test_dentry[2]);
468
469 test("bravo/alfa |bravo/alfa ", "%-12pd2|%*pd2", &test_dentry[2], -12, &test_dentry[2]);
470 test(" bravo/alfa| bravo/alfa", "%12pd2|%*pd2", &test_dentry[2], 12, &test_dentry[2]);
471 }
472
473 static void __init
struct_va_format(void)474 struct_va_format(void)
475 {
476 }
477
478 static void __init
struct_rtc_time(void)479 struct_rtc_time(void)
480 {
481 /* 1543210543 */
482 const struct rtc_time tm = {
483 .tm_sec = 43,
484 .tm_min = 35,
485 .tm_hour = 5,
486 .tm_mday = 26,
487 .tm_mon = 10,
488 .tm_year = 118,
489 };
490
491 test("(%ptR?)", "%pt", &tm);
492 test("2018-11-26T05:35:43", "%ptR", &tm);
493 test("0118-10-26T05:35:43", "%ptRr", &tm);
494 test("05:35:43|2018-11-26", "%ptRt|%ptRd", &tm, &tm);
495 test("05:35:43|0118-10-26", "%ptRtr|%ptRdr", &tm, &tm);
496 test("05:35:43|2018-11-26", "%ptRttr|%ptRdtr", &tm, &tm);
497 test("05:35:43 tr|2018-11-26 tr", "%ptRt tr|%ptRd tr", &tm, &tm);
498 }
499
500 static void __init
struct_clk(void)501 struct_clk(void)
502 {
503 }
504
505 static void __init
large_bitmap(void)506 large_bitmap(void)
507 {
508 const int nbits = 1 << 16;
509 unsigned long *bits = bitmap_zalloc(nbits, GFP_KERNEL);
510 if (!bits)
511 return;
512
513 bitmap_set(bits, 1, 20);
514 bitmap_set(bits, 60000, 15);
515 test("1-20,60000-60014", "%*pbl", nbits, bits);
516 bitmap_free(bits);
517 }
518
519 static void __init
bitmap(void)520 bitmap(void)
521 {
522 DECLARE_BITMAP(bits, 20);
523 const int primes[] = {2,3,5,7,11,13,17,19};
524 int i;
525
526 bitmap_zero(bits, 20);
527 test("00000|00000", "%20pb|%*pb", bits, 20, bits);
528 test("|", "%20pbl|%*pbl", bits, 20, bits);
529
530 for (i = 0; i < ARRAY_SIZE(primes); ++i)
531 set_bit(primes[i], bits);
532 test("a28ac|a28ac", "%20pb|%*pb", bits, 20, bits);
533 test("2-3,5,7,11,13,17,19|2-3,5,7,11,13,17,19", "%20pbl|%*pbl", bits, 20, bits);
534
535 bitmap_fill(bits, 20);
536 test("fffff|fffff", "%20pb|%*pb", bits, 20, bits);
537 test("0-19|0-19", "%20pbl|%*pbl", bits, 20, bits);
538
539 large_bitmap();
540 }
541
542 static void __init
netdev_features(void)543 netdev_features(void)
544 {
545 }
546
547 static void __init
flags(void)548 flags(void)
549 {
550 unsigned long flags;
551 gfp_t gfp;
552 char *cmp_buffer;
553
554 flags = 0;
555 test("", "%pGp", &flags);
556
557 /* Page flags should filter the zone id */
558 flags = 1UL << NR_PAGEFLAGS;
559 test("", "%pGp", &flags);
560
561 flags |= 1UL << PG_uptodate | 1UL << PG_dirty | 1UL << PG_lru
562 | 1UL << PG_active | 1UL << PG_swapbacked;
563 test("uptodate|dirty|lru|active|swapbacked", "%pGp", &flags);
564
565
566 flags = VM_READ | VM_EXEC | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC
567 | VM_DENYWRITE;
568 test("read|exec|mayread|maywrite|mayexec|denywrite", "%pGv", &flags);
569
570 gfp = GFP_TRANSHUGE;
571 test("GFP_TRANSHUGE", "%pGg", &gfp);
572
573 gfp = GFP_ATOMIC|__GFP_DMA;
574 test("GFP_ATOMIC|GFP_DMA", "%pGg", &gfp);
575
576 gfp = __GFP_ATOMIC;
577 test("__GFP_ATOMIC", "%pGg", &gfp);
578
579 cmp_buffer = kmalloc(BUF_SIZE, GFP_KERNEL);
580 if (!cmp_buffer)
581 return;
582
583 /* Any flags not translated by the table should remain numeric */
584 gfp = ~__GFP_BITS_MASK;
585 snprintf(cmp_buffer, BUF_SIZE, "%#lx", (unsigned long) gfp);
586 test(cmp_buffer, "%pGg", &gfp);
587
588 snprintf(cmp_buffer, BUF_SIZE, "__GFP_ATOMIC|%#lx",
589 (unsigned long) gfp);
590 gfp |= __GFP_ATOMIC;
591 test(cmp_buffer, "%pGg", &gfp);
592
593 kfree(cmp_buffer);
594 }
595
596 static void __init
test_pointer(void)597 test_pointer(void)
598 {
599 plain();
600 null_pointer();
601 invalid_pointer();
602 symbol_ptr();
603 kernel_ptr();
604 struct_resource();
605 addr();
606 escaped_str();
607 hex_string();
608 mac();
609 ip();
610 uuid();
611 dentry();
612 struct_va_format();
613 struct_rtc_time();
614 struct_clk();
615 bitmap();
616 netdev_features();
617 flags();
618 }
619
selftest(void)620 static void __init selftest(void)
621 {
622 alloced_buffer = kmalloc(BUF_SIZE + 2*PAD_SIZE, GFP_KERNEL);
623 if (!alloced_buffer)
624 return;
625 test_buffer = alloced_buffer + PAD_SIZE;
626
627 test_basic();
628 test_number();
629 test_string();
630 test_pointer();
631
632 kfree(alloced_buffer);
633 }
634
635 KSTM_MODULE_LOADERS(test_printf);
636 MODULE_AUTHOR("Rasmus Villemoes <linux@rasmusvillemoes.dk>");
637 MODULE_LICENSE("GPL");
638