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