Blame view
lib/test_printf.c
16.6 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 |
#define ZEROS "00000000" /* hex 32 zero bits */ |
7bd57fbc4 vsprintf: don't o... |
212 |
#define ONES "ffffffff" /* hex 32 one bits */ |
ad67b74d2 printk: hash addr... |
213 214 215 216 217 218 219 220 |
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... |
221 222 223 224 225 226 227 228 229 230 |
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... |
231 232 233 234 235 236 237 238 239 240 |
return -1; return 0; } #else #define PTR_WIDTH 8 #define PTR ((void *)0x456789ab) #define PTR_STR "456789ab" |
ce041c43f lib/test_printf.c... |
241 |
#define PTR_VAL_NO_CRNG "(ptrval)" |
3e5903eb9 vsprintf: Prevent... |
242 |
#define ZEROS "" |
7bd57fbc4 vsprintf: don't o... |
243 |
#define ONES "" |
ad67b74d2 printk: hash addr... |
244 245 246 247 248 249 250 251 252 253 254 |
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... |
255 |
plain_hash_to_buffer(const void *p, char *buf, size_t len) |
ad67b74d2 printk: hash addr... |
256 |
{ |
ad67b74d2 printk: hash addr... |
257 |
int nchars; |
4d42c4472 lib/vsprintf: Pri... |
258 |
nchars = snprintf(buf, len, "%p", p); |
ad67b74d2 printk: hash addr... |
259 |
|
ce041c43f lib/test_printf.c... |
260 261 262 263 264 265 266 267 |
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... |
268 269 |
return 0; } |
4d42c4472 lib/vsprintf: Pri... |
270 271 272 273 274 275 276 277 278 |
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... |
279 |
if (strncmp(buf, PTR_STR, PTR_WIDTH) == 0) |
ad67b74d2 printk: hash addr... |
280 281 282 283 284 285 286 287 288 |
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... |
289 290 291 |
static void __init plain(void) { |
ad67b74d2 printk: hash addr... |
292 |
int err; |
707cc7280 test_printf: test... |
293 |
|
ad67b74d2 printk: hash addr... |
294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
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... |
308 309 310 |
} static void __init |
4d42c4472 lib/vsprintf: Pri... |
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); } |
7bd57fbc4 vsprintf: don't o... |
326 327 328 |
/* * NULL pointers aren't hashed. */ |
4d42c4472 lib/vsprintf: Pri... |
329 |
static void __init |
3e5903eb9 vsprintf: Prevent... |
330 331 |
null_pointer(void) { |
7bd57fbc4 vsprintf: don't o... |
332 |
test(ZEROS "00000000", "%p", NULL); |
3e5903eb9 vsprintf: Prevent... |
333 334 335 |
test(ZEROS "00000000", "%px", NULL); test("(null)", "%pE", NULL); } |
7bd57fbc4 vsprintf: don't o... |
336 337 338 339 340 341 342 343 344 345 |
/* * Error pointers aren't hashed. */ static void __init error_pointer(void) { test(ONES "fffffff5", "%p", ERR_PTR(-11)); test(ONES "fffffff5", "%px", ERR_PTR(-11)); test("(efault)", "%pE", ERR_PTR(-11)); } |
3e5903eb9 vsprintf: Prevent... |
346 347 348 349 350 351 352 353 354 355 356 |
#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... |
357 358 359 360 361 362 363 |
symbol_ptr(void) { } static void __init kernel_ptr(void) { |
ad67b74d2 printk: hash addr... |
364 |
/* We can't test this without access to kptr_restrict. */ |
707cc7280 test_printf: test... |
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 430 431 432 433 434 435 436 437 438 439 440 441 442 |
} 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... |
443 444 445 446 447 448 449 450 451 452 453 454 455 456 |
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... |
457 458 459 |
static void __init dentry(void) { |
251c72345 lib/test_printf.c... |
460 461 |
test("foo", "%pd", &test_dentry[0]); test("foo", "%pd2", &test_dentry[0]); |
cf6b7921f lib/test_printf: ... |
462 463 |
test("(null)", "%pd", NULL); test("(efault)", "%pd", PTR_INVALID); |
cf6b7921f lib/test_printf: ... |
464 465 |
test("(null)", "%pD", NULL); test("(efault)", "%pD", PTR_INVALID); |
251c72345 lib/test_printf.c... |
466 467 468 469 470 471 472 473 |
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... |
474 475 476 477 478 479 480 481 |
} static void __init struct_va_format(void) { } static void __init |
7daac5b2f lib/vsprintf: Pri... |
482 |
time_and_date(void) |
4d42c4472 lib/vsprintf: Pri... |
483 484 485 486 487 488 489 490 491 492 |
{ /* 1543210543 */ const struct rtc_time tm = { .tm_sec = 43, .tm_min = 35, .tm_hour = 5, .tm_mday = 26, .tm_mon = 10, .tm_year = 118, }; |
7daac5b2f lib/vsprintf: Pri... |
493 494 |
/* 2019-01-04T15:32:23 */ time64_t t = 1546615943; |
4d42c4472 lib/vsprintf: Pri... |
495 |
|
7daac5b2f lib/vsprintf: Pri... |
496 |
test("(%pt?)", "%pt", &tm); |
4d42c4472 lib/vsprintf: Pri... |
497 498 499 500 501 502 |
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); |
7daac5b2f lib/vsprintf: Pri... |
503 504 505 506 507 |
test("2019-01-04T15:32:23", "%ptT", &t); test("0119-00-04T15:32:23", "%ptTr", &t); test("15:32:23|2019-01-04", "%ptTt|%ptTd", &t, &t); test("15:32:23|0119-00-04", "%ptTtr|%ptTdr", &t, &t); |
4d42c4472 lib/vsprintf: Pri... |
508 509 510 |
} static void __init |
707cc7280 test_printf: test... |
511 512 513 514 515 |
struct_clk(void) { } static void __init |
857cca4d5 lib/test_printf.c... |
516 517 518 |
large_bitmap(void) { const int nbits = 1 << 16; |
2821fd0c2 lib/test_printf: ... |
519 |
unsigned long *bits = bitmap_zalloc(nbits, GFP_KERNEL); |
857cca4d5 lib/test_printf.c... |
520 521 522 523 524 525 |
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: ... |
526 |
bitmap_free(bits); |
857cca4d5 lib/test_printf.c... |
527 528 529 |
} static void __init |
707cc7280 test_printf: test... |
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 |
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... |
548 549 |
large_bitmap(); |
707cc7280 test_printf: test... |
550 551 552 553 554 555 556 557 |
} static void __init netdev_features(void) { } static void __init |
edf14cdbf mm, printk: intro... |
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 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 |
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: ... |
605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 |
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])); |
46d26819a software node: im... |
631 632 633 |
software_node_unregister(&softnodes[2]); software_node_unregister(&softnodes[1]); software_node_unregister(&softnodes[0]); |
f1ce39df5 lib/test_printf: ... |
634 |
} |
edf14cdbf mm, printk: intro... |
635 |
static void __init |
57f5677e5 printf: add suppo... |
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 |
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... |
656 657 658 |
test_pointer(void) { plain(); |
3e5903eb9 vsprintf: Prevent... |
659 |
null_pointer(); |
7bd57fbc4 vsprintf: don't o... |
660 |
error_pointer(); |
3e5903eb9 vsprintf: Prevent... |
661 |
invalid_pointer(); |
707cc7280 test_printf: test... |
662 663 664 665 666 667 668 669 670 671 672 |
symbol_ptr(); kernel_ptr(); struct_resource(); addr(); escaped_str(); hex_string(); mac(); ip(); uuid(); dentry(); struct_va_format(); |
7daac5b2f lib/vsprintf: Pri... |
673 |
time_and_date(); |
707cc7280 test_printf: test... |
674 675 676 |
struct_clk(); bitmap(); netdev_features(); |
edf14cdbf mm, printk: intro... |
677 |
flags(); |
57f5677e5 printf: add suppo... |
678 |
errptr(); |
f1ce39df5 lib/test_printf: ... |
679 |
fwnode_pointer(); |
707cc7280 test_printf: test... |
680 |
} |
6b1a4d5b1 lib: Use new ksel... |
681 |
static void __init selftest(void) |
707cc7280 test_printf: test... |
682 |
{ |
331e4deb6 lib/test_printf.c... |
683 684 |
alloced_buffer = kmalloc(BUF_SIZE + 2*PAD_SIZE, GFP_KERNEL); if (!alloced_buffer) |
6b1a4d5b1 lib: Use new ksel... |
685 |
return; |
331e4deb6 lib/test_printf.c... |
686 |
test_buffer = alloced_buffer + PAD_SIZE; |
707cc7280 test_printf: test... |
687 688 689 690 691 |
test_basic(); test_number(); test_string(); test_pointer(); |
331e4deb6 lib/test_printf.c... |
692 |
kfree(alloced_buffer); |
707cc7280 test_printf: test... |
693 |
} |
6b1a4d5b1 lib: Use new ksel... |
694 |
KSTM_MODULE_LOADERS(test_printf); |
707cc7280 test_printf: test... |
695 696 |
MODULE_AUTHOR("Rasmus Villemoes <linux@rasmusvillemoes.dk>"); MODULE_LICENSE("GPL"); |