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