Blame view
lib/test_printf.c
16 KB
09c434b8a treewide: Add SPD... |
1 |
// SPDX-License-Identifier: GPL-2.0-only |
707cc7280 test_printf: test... |
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 lib/vsprintf: Pri... |
13 |
#include <linux/rtc.h> |
707cc7280 test_printf: test... |
14 15 |
#include <linux/slab.h> #include <linux/string.h> |
857cca4d5 lib/test_printf.c... |
16 |
#include <linux/bitmap.h> |
251c72345 lib/test_printf.c... |
17 |
#include <linux/dcache.h> |
707cc7280 test_printf: test... |
18 19 |
#include <linux/socket.h> #include <linux/in.h> |
edf14cdbf mm, printk: intro... |
20 21 |
#include <linux/gfp.h> #include <linux/mm.h> |
f1ce39df5 lib/test_printf: ... |
22 |
#include <linux/property.h> |
6b1a4d5b1 lib: Use new ksel... |
23 |
#include "../tools/testing/selftests/kselftest_module.h" |
707cc7280 test_printf: test... |
24 |
#define BUF_SIZE 256 |
331e4deb6 lib/test_printf.c... |
25 |
#define PAD_SIZE 16 |
707cc7280 test_printf: test... |
26 |
#define FILL_CHAR '$' |
707cc7280 test_printf: test... |
27 28 29 |
static unsigned total_tests __initdata; static unsigned failed_tests __initdata; static char *test_buffer __initdata; |
331e4deb6 lib/test_printf.c... |
30 |
static char *alloced_buffer __initdata; |
707cc7280 test_printf: test... |
31 32 33 34 35 36 37 38 39 |
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 lib/test_printf.c... |
40 |
memset(alloced_buffer, FILL_CHAR, BUF_SIZE + 2*PAD_SIZE); |
707cc7280 test_printf: test... |
41 42 43 44 45 46 47 48 49 50 |
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 lib/test_printf.c... |
51 52 53 54 55 |
if (memchr_inv(alloced_buffer, FILL_CHAR, PAD_SIZE)) { pr_warn("vsnprintf(buf, %d, \"%s\", ...) wrote before buffer ", bufsize, fmt); return 1; } |
707cc7280 test_printf: test... |
56 |
if (!bufsize) { |
331e4deb6 lib/test_printf.c... |
57 |
if (memchr_inv(test_buffer, FILL_CHAR, BUF_SIZE + PAD_SIZE)) { |
707cc7280 test_printf: test... |
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
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 lib/test_printf.c... |
73 74 75 76 77 78 |
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 test_printf: test... |
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
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 lib/test_printf.c... |
94 95 96 97 98 99 100 |
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 test_printf: test... |
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
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 lib/test_printf.c... |
118 |
total_tests++; |
707cc7280 test_printf: test... |
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 150 |
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 lib/test_printf.c... |
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
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 test_printf: test... |
175 176 177 178 179 180 181 182 |
} 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 lib/test_printf.c... |
183 184 |
test("1234 ", "%-10.4s", "123456"); test(" 1234", "%10.4s", "123456"); |
707cc7280 test_printf: test... |
185 |
/* |
f176eb4ce lib/test_printf.c... |
186 187 188 189 190 191 192 193 194 195 196 |
* 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 test_printf: test... |
197 |
*/ |
f176eb4ce lib/test_printf.c... |
198 199 |
test(" ", "%4.*s", -5, "123456"); test("123456", "%.s", "123456"); |
707cc7280 test_printf: test... |
200 201 202 |
test("a||", "%.s|%.0s|%.*s", "a", "b", 0, "c"); test("a | | ", "%-3.s|%-3.0s|%-3.*s", "a", "b", 0, "c"); } |
ad67b74d2 printk: hash addr... |
203 204 205 206 207 |
#define PLAIN_BUF_SIZE 64 /* leave some space so we don't oops */ #if BITS_PER_LONG == 64 #define PTR_WIDTH 16 |
c604b4072 lib/test_printf: ... |
208 |
#define PTR ((void *)0xffff0123456789abUL) |
ad67b74d2 printk: hash addr... |
209 |
#define PTR_STR "ffff0123456789ab" |
ce041c43f lib/test_printf.c... |
210 |
#define PTR_VAL_NO_CRNG "(____ptrval____)" |
ad67b74d2 printk: hash addr... |
211 212 213 214 215 216 217 218 219 |
#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 lib/test_printf.c... |
220 221 222 223 224 225 226 227 228 229 |
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 printk: hash addr... |
230 231 232 233 234 235 236 237 238 239 |
return -1; return 0; } #else #define PTR_WIDTH 8 #define PTR ((void *)0x456789ab) #define PTR_STR "456789ab" |
ce041c43f lib/test_printf.c... |
240 |
#define PTR_VAL_NO_CRNG "(ptrval)" |
3e5903eb9 vsprintf: Prevent... |
241 |
#define ZEROS "" |
ad67b74d2 printk: hash addr... |
242 243 244 245 246 247 248 249 250 251 252 |
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 lib/vsprintf: Pri... |
253 |
plain_hash_to_buffer(const void *p, char *buf, size_t len) |
ad67b74d2 printk: hash addr... |
254 |
{ |
ad67b74d2 printk: hash addr... |
255 |
int nchars; |
4d42c4472 lib/vsprintf: Pri... |
256 |
nchars = snprintf(buf, len, "%p", p); |
ad67b74d2 printk: hash addr... |
257 |
|
ce041c43f lib/test_printf.c... |
258 259 260 261 262 263 264 265 |
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 lib/vsprintf: Pri... |
266 267 |
return 0; } |
4d42c4472 lib/vsprintf: Pri... |
268 269 270 271 272 273 274 275 276 |
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 lib/test_printf.c... |
277 |
if (strncmp(buf, PTR_STR, PTR_WIDTH) == 0) |
ad67b74d2 printk: hash addr... |
278 279 280 281 282 283 284 285 286 |
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 test_printf: test... |
287 288 289 |
static void __init plain(void) { |
ad67b74d2 printk: hash addr... |
290 |
int err; |
707cc7280 test_printf: test... |
291 |
|
ad67b74d2 printk: hash addr... |
292 293 294 295 296 297 298 299 300 301 302 303 304 305 |
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 test_printf: test... |
306 307 308 |
} static void __init |
4d42c4472 lib/vsprintf: Pri... |
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 |
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 vsprintf: Prevent... |
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 |
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 test_printf: test... |
344 345 346 347 348 349 350 |
symbol_ptr(void) { } static void __init kernel_ptr(void) { |
ad67b74d2 printk: hash addr... |
351 |
/* We can't test this without access to kptr_restrict. */ |
707cc7280 test_printf: test... |
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 429 |
} 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 lib/test_printf.c... |
430 431 432 433 434 435 436 437 438 439 440 441 442 443 |
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 test_printf: test... |
444 445 446 |
static void __init dentry(void) { |
251c72345 lib/test_printf.c... |
447 448 |
test("foo", "%pd", &test_dentry[0]); test("foo", "%pd2", &test_dentry[0]); |
cf6b7921f lib/test_printf: ... |
449 450 |
test("(null)", "%pd", NULL); test("(efault)", "%pd", PTR_INVALID); |
cf6b7921f lib/test_printf: ... |
451 452 |
test("(null)", "%pD", NULL); test("(efault)", "%pD", PTR_INVALID); |
251c72345 lib/test_printf.c... |
453 454 455 456 457 458 459 460 |
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 test_printf: test... |
461 462 463 464 465 466 467 468 |
} static void __init struct_va_format(void) { } static void __init |
4d42c4472 lib/vsprintf: Pri... |
469 470 471 472 473 474 475 476 477 478 479 |
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 vsprintf: Consoli... |
480 |
test("(%ptR?)", "%pt", &tm); |
4d42c4472 lib/vsprintf: Pri... |
481 482 483 484 485 486 487 488 489 |
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 test_printf: test... |
490 491 492 493 494 |
struct_clk(void) { } static void __init |
857cca4d5 lib/test_printf.c... |
495 496 497 |
large_bitmap(void) { const int nbits = 1 << 16; |
2821fd0c2 lib/test_printf: ... |
498 |
unsigned long *bits = bitmap_zalloc(nbits, GFP_KERNEL); |
857cca4d5 lib/test_printf.c... |
499 500 501 502 503 504 |
if (!bits) return; bitmap_set(bits, 1, 20); bitmap_set(bits, 60000, 15); test("1-20,60000-60014", "%*pbl", nbits, bits); |
2821fd0c2 lib/test_printf: ... |
505 |
bitmap_free(bits); |
857cca4d5 lib/test_printf.c... |
506 507 508 |
} static void __init |
707cc7280 test_printf: test... |
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 |
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 lib/test_printf.c... |
527 528 |
large_bitmap(); |
707cc7280 test_printf: test... |
529 530 531 532 533 534 535 536 |
} static void __init netdev_features(void) { } static void __init |
edf14cdbf mm, printk: intro... |
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 582 583 |
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); } |
f1ce39df5 lib/test_printf: ... |
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 |
static void __init fwnode_pointer(void) { const struct software_node softnodes[] = { { .name = "first", }, { .name = "second", .parent = &softnodes[0], }, { .name = "third", .parent = &softnodes[1], }, { NULL /* Guardian */ } }; const char * const full_name = "first/second/third"; const char * const full_name_second = "first/second"; const char * const second_name = "second"; const char * const third_name = "third"; int rval; rval = software_node_register_nodes(softnodes); if (rval) { pr_warn("cannot register softnodes; rval %d ", rval); return; } test(full_name_second, "%pfw", software_node_fwnode(&softnodes[1])); test(full_name, "%pfw", software_node_fwnode(&softnodes[2])); test(full_name, "%pfwf", software_node_fwnode(&softnodes[2])); test(second_name, "%pfwP", software_node_fwnode(&softnodes[1])); test(third_name, "%pfwP", software_node_fwnode(&softnodes[2])); software_node_unregister_nodes(softnodes); } |
edf14cdbf mm, printk: intro... |
613 |
static void __init |
57f5677e5 printf: add suppo... |
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 |
errptr(void) { test("-1234", "%pe", ERR_PTR(-1234)); /* Check that %pe with a non-ERR_PTR gets treated as ordinary %p. */ BUILD_BUG_ON(IS_ERR(PTR)); test_hashed("%pe", PTR); #ifdef CONFIG_SYMBOLIC_ERRNAME test("(-ENOTSOCK)", "(%pe)", ERR_PTR(-ENOTSOCK)); test("(-EAGAIN)", "(%pe)", ERR_PTR(-EAGAIN)); BUILD_BUG_ON(EAGAIN != EWOULDBLOCK); test("(-EAGAIN)", "(%pe)", ERR_PTR(-EWOULDBLOCK)); test("[-EIO ]", "[%-8pe]", ERR_PTR(-EIO)); test("[ -EIO]", "[%8pe]", ERR_PTR(-EIO)); test("-EPROBE_DEFER", "%pe", ERR_PTR(-EPROBE_DEFER)); #endif } static void __init |
707cc7280 test_printf: test... |
634 635 636 |
test_pointer(void) { plain(); |
3e5903eb9 vsprintf: Prevent... |
637 638 |
null_pointer(); invalid_pointer(); |
707cc7280 test_printf: test... |
639 640 641 642 643 644 645 646 647 648 649 |
symbol_ptr(); kernel_ptr(); struct_resource(); addr(); escaped_str(); hex_string(); mac(); ip(); uuid(); dentry(); struct_va_format(); |
4d42c4472 lib/vsprintf: Pri... |
650 |
struct_rtc_time(); |
707cc7280 test_printf: test... |
651 652 653 |
struct_clk(); bitmap(); netdev_features(); |
edf14cdbf mm, printk: intro... |
654 |
flags(); |
57f5677e5 printf: add suppo... |
655 |
errptr(); |
f1ce39df5 lib/test_printf: ... |
656 |
fwnode_pointer(); |
707cc7280 test_printf: test... |
657 |
} |
6b1a4d5b1 lib: Use new ksel... |
658 |
static void __init selftest(void) |
707cc7280 test_printf: test... |
659 |
{ |
331e4deb6 lib/test_printf.c... |
660 661 |
alloced_buffer = kmalloc(BUF_SIZE + 2*PAD_SIZE, GFP_KERNEL); if (!alloced_buffer) |
6b1a4d5b1 lib: Use new ksel... |
662 |
return; |
331e4deb6 lib/test_printf.c... |
663 |
test_buffer = alloced_buffer + PAD_SIZE; |
707cc7280 test_printf: test... |
664 665 666 667 668 |
test_basic(); test_number(); test_string(); test_pointer(); |
331e4deb6 lib/test_printf.c... |
669 |
kfree(alloced_buffer); |
707cc7280 test_printf: test... |
670 |
} |
6b1a4d5b1 lib: Use new ksel... |
671 |
KSTM_MODULE_LOADERS(test_printf); |
707cc7280 test_printf: test... |
672 673 |
MODULE_AUTHOR("Rasmus Villemoes <linux@rasmusvillemoes.dk>"); MODULE_LICENSE("GPL"); |