1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KCSAN test with various race scenarious to test runtime behaviour. Since the 4 * interface with which KCSAN's reports are obtained is via the console, this is 5 * the output we should verify. For each test case checks the presence (or 6 * absence) of generated reports. Relies on 'console' tracepoint to capture 7 * reports as they appear in the kernel log. 8 * 9 * Makes use of KUnit for test organization, and the Torture framework for test 10 * thread control. 11 * 12 * Copyright (C) 2020, Google LLC. 13 * Author: Marco Elver <[email protected]> 14 */ 15 16 #define pr_fmt(fmt) "kcsan_test: " fmt 17 18 #include <kunit/test.h> 19 #include <linux/atomic.h> 20 #include <linux/bitops.h> 21 #include <linux/jiffies.h> 22 #include <linux/kcsan-checks.h> 23 #include <linux/kernel.h> 24 #include <linux/mutex.h> 25 #include <linux/sched.h> 26 #include <linux/seqlock.h> 27 #include <linux/spinlock.h> 28 #include <linux/string.h> 29 #include <linux/timer.h> 30 #include <linux/torture.h> 31 #include <linux/tracepoint.h> 32 #include <linux/types.h> 33 #include <trace/events/printk.h> 34 35 #define KCSAN_TEST_REQUIRES(test, cond) do { \ 36 if (!(cond)) \ 37 kunit_skip((test), "Test requires: " #cond); \ 38 } while (0) 39 40 #ifdef CONFIG_CC_HAS_TSAN_COMPOUND_READ_BEFORE_WRITE 41 #define __KCSAN_ACCESS_RW(alt) (KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE) 42 #else 43 #define __KCSAN_ACCESS_RW(alt) (alt) 44 #endif 45 46 /* Points to current test-case memory access "kernels". */ 47 static void (*access_kernels[2])(void); 48 49 static struct task_struct **threads; /* Lists of threads. */ 50 static unsigned long end_time; /* End time of test. */ 51 52 /* Report as observed from console. */ 53 static struct { 54 spinlock_t lock; 55 int nlines; 56 char lines[3][512]; 57 } observed = { 58 .lock = __SPIN_LOCK_UNLOCKED(observed.lock), 59 }; 60 61 /* Setup test checking loop. */ 62 static __no_kcsan inline void 63 begin_test_checks(void (*func1)(void), void (*func2)(void)) 64 { 65 kcsan_disable_current(); 66 67 /* 68 * Require at least as long as KCSAN_REPORT_ONCE_IN_MS, to ensure at 69 * least one race is reported. 70 */ 71 end_time = jiffies + msecs_to_jiffies(CONFIG_KCSAN_REPORT_ONCE_IN_MS + 500); 72 73 /* Signal start; release potential initialization of shared data. */ 74 smp_store_release(&access_kernels[0], func1); 75 smp_store_release(&access_kernels[1], func2); 76 } 77 78 /* End test checking loop. */ 79 static __no_kcsan inline bool 80 end_test_checks(bool stop) 81 { 82 if (!stop && time_before(jiffies, end_time)) { 83 /* Continue checking */ 84 might_sleep(); 85 return false; 86 } 87 88 kcsan_enable_current(); 89 return true; 90 } 91 92 /* 93 * Probe for console output: checks if a race was reported, and obtains observed 94 * lines of interest. 95 */ 96 __no_kcsan 97 static void probe_console(void *ignore, const char *buf, size_t len) 98 { 99 unsigned long flags; 100 int nlines; 101 102 /* 103 * Note that KCSAN reports under a global lock, so we do not risk the 104 * possibility of having multiple reports interleaved. If that were the 105 * case, we'd expect tests to fail. 106 */ 107 108 spin_lock_irqsave(&observed.lock, flags); 109 nlines = observed.nlines; 110 111 if (strnstr(buf, "BUG: KCSAN: ", len) && strnstr(buf, "test_", len)) { 112 /* 113 * KCSAN report and related to the test. 114 * 115 * The provided @buf is not NUL-terminated; copy no more than 116 * @len bytes and let strscpy() add the missing NUL-terminator. 117 */ 118 strscpy(observed.lines[0], buf, min(len + 1, sizeof(observed.lines[0]))); 119 nlines = 1; 120 } else if ((nlines == 1 || nlines == 2) && strnstr(buf, "bytes by", len)) { 121 strscpy(observed.lines[nlines++], buf, min(len + 1, sizeof(observed.lines[0]))); 122 123 if (strnstr(buf, "race at unknown origin", len)) { 124 if (WARN_ON(nlines != 2)) 125 goto out; 126 127 /* No second line of interest. */ 128 strcpy(observed.lines[nlines++], "<none>"); 129 } 130 } 131 132 out: 133 WRITE_ONCE(observed.nlines, nlines); /* Publish new nlines. */ 134 spin_unlock_irqrestore(&observed.lock, flags); 135 } 136 137 /* Check if a report related to the test exists. */ 138 __no_kcsan 139 static bool report_available(void) 140 { 141 return READ_ONCE(observed.nlines) == ARRAY_SIZE(observed.lines); 142 } 143 144 /* Report information we expect in a report. */ 145 struct expect_report { 146 /* Access information of both accesses. */ 147 struct { 148 void *fn; /* Function pointer to expected function of top frame. */ 149 void *addr; /* Address of access; unchecked if NULL. */ 150 size_t size; /* Size of access; unchecked if @addr is NULL. */ 151 int type; /* Access type, see KCSAN_ACCESS definitions. */ 152 } access[2]; 153 }; 154 155 /* Check observed report matches information in @r. */ 156 __no_kcsan 157 static bool __report_matches(const struct expect_report *r) 158 { 159 const bool is_assert = (r->access[0].type | r->access[1].type) & KCSAN_ACCESS_ASSERT; 160 bool ret = false; 161 unsigned long flags; 162 typeof(observed.lines) expect; 163 const char *end; 164 char *cur; 165 int i; 166 167 /* Doubled-checked locking. */ 168 if (!report_available()) 169 return false; 170 171 /* Generate expected report contents. */ 172 173 /* Title */ 174 cur = expect[0]; 175 end = &expect[0][sizeof(expect[0]) - 1]; 176 cur += scnprintf(cur, end - cur, "BUG: KCSAN: %s in ", 177 is_assert ? "assert: race" : "data-race"); 178 if (r->access[1].fn) { 179 char tmp[2][64]; 180 int cmp; 181 182 /* Expect lexographically sorted function names in title. */ 183 scnprintf(tmp[0], sizeof(tmp[0]), "%pS", r->access[0].fn); 184 scnprintf(tmp[1], sizeof(tmp[1]), "%pS", r->access[1].fn); 185 cmp = strcmp(tmp[0], tmp[1]); 186 cur += scnprintf(cur, end - cur, "%ps / %ps", 187 cmp < 0 ? r->access[0].fn : r->access[1].fn, 188 cmp < 0 ? r->access[1].fn : r->access[0].fn); 189 } else { 190 scnprintf(cur, end - cur, "%pS", r->access[0].fn); 191 /* The exact offset won't match, remove it. */ 192 cur = strchr(expect[0], '+'); 193 if (cur) 194 *cur = '\0'; 195 } 196 197 /* Access 1 */ 198 cur = expect[1]; 199 end = &expect[1][sizeof(expect[1]) - 1]; 200 if (!r->access[1].fn) 201 cur += scnprintf(cur, end - cur, "race at unknown origin, with "); 202 203 /* Access 1 & 2 */ 204 for (i = 0; i < 2; ++i) { 205 const int ty = r->access[i].type; 206 const char *const access_type = 207 (ty & KCSAN_ACCESS_ASSERT) ? 208 ((ty & KCSAN_ACCESS_WRITE) ? 209 "assert no accesses" : 210 "assert no writes") : 211 ((ty & KCSAN_ACCESS_WRITE) ? 212 ((ty & KCSAN_ACCESS_COMPOUND) ? 213 "read-write" : 214 "write") : 215 "read"); 216 const bool is_atomic = (ty & KCSAN_ACCESS_ATOMIC); 217 const bool is_scoped = (ty & KCSAN_ACCESS_SCOPED); 218 const char *const access_type_aux = 219 (is_atomic && is_scoped) ? " (marked, reordered)" 220 : (is_atomic ? " (marked)" 221 : (is_scoped ? " (reordered)" : "")); 222 223 if (i == 1) { 224 /* Access 2 */ 225 cur = expect[2]; 226 end = &expect[2][sizeof(expect[2]) - 1]; 227 228 if (!r->access[1].fn) { 229 /* Dummy string if no second access is available. */ 230 strcpy(cur, "<none>"); 231 break; 232 } 233 } 234 235 cur += scnprintf(cur, end - cur, "%s%s to ", access_type, 236 access_type_aux); 237 238 if (r->access[i].addr) /* Address is optional. */ 239 cur += scnprintf(cur, end - cur, "0x%px of %zu bytes", 240 r->access[i].addr, r->access[i].size); 241 } 242 243 spin_lock_irqsave(&observed.lock, flags); 244 if (!report_available()) 245 goto out; /* A new report is being captured. */ 246 247 /* Finally match expected output to what we actually observed. */ 248 ret = strstr(observed.lines[0], expect[0]) && 249 /* Access info may appear in any order. */ 250 ((strstr(observed.lines[1], expect[1]) && 251 strstr(observed.lines[2], expect[2])) || 252 (strstr(observed.lines[1], expect[2]) && 253 strstr(observed.lines[2], expect[1]))); 254 out: 255 spin_unlock_irqrestore(&observed.lock, flags); 256 return ret; 257 } 258 259 static __always_inline const struct expect_report * 260 __report_set_scoped(struct expect_report *r, int accesses) 261 { 262 BUILD_BUG_ON(accesses > 3); 263 264 if (accesses & 1) 265 r->access[0].type |= KCSAN_ACCESS_SCOPED; 266 else 267 r->access[0].type &= ~KCSAN_ACCESS_SCOPED; 268 269 if (accesses & 2) 270 r->access[1].type |= KCSAN_ACCESS_SCOPED; 271 else 272 r->access[1].type &= ~KCSAN_ACCESS_SCOPED; 273 274 return r; 275 } 276 277 __no_kcsan 278 static bool report_matches_any_reordered(struct expect_report *r) 279 { 280 return __report_matches(__report_set_scoped(r, 0)) || 281 __report_matches(__report_set_scoped(r, 1)) || 282 __report_matches(__report_set_scoped(r, 2)) || 283 __report_matches(__report_set_scoped(r, 3)); 284 } 285 286 #ifdef CONFIG_KCSAN_WEAK_MEMORY 287 /* Due to reordering accesses, any access may appear as "(reordered)". */ 288 #define report_matches report_matches_any_reordered 289 #else 290 #define report_matches __report_matches 291 #endif 292 293 /* ===== Test kernels ===== */ 294 295 static long test_sink; 296 static long test_var; 297 /* @test_array should be large enough to fall into multiple watchpoint slots. */ 298 static long test_array[3 * PAGE_SIZE / sizeof(long)]; 299 static struct { 300 long val[8]; 301 } test_struct; 302 static DEFINE_SEQLOCK(test_seqlock); 303 static DEFINE_SPINLOCK(test_spinlock); 304 static DEFINE_MUTEX(test_mutex); 305 306 /* 307 * Helper to avoid compiler optimizing out reads, and to generate source values 308 * for writes. 309 */ 310 __no_kcsan 311 static noinline void sink_value(long v) { WRITE_ONCE(test_sink, v); } 312 313 /* 314 * Generates a delay and some accesses that enter the runtime but do not produce 315 * data races. 316 */ 317 static noinline void test_delay(int iter) 318 { 319 while (iter--) 320 sink_value(READ_ONCE(test_sink)); 321 } 322 323 static noinline void test_kernel_read(void) { sink_value(test_var); } 324 325 static noinline void test_kernel_write(void) 326 { 327 test_var = READ_ONCE_NOCHECK(test_sink) + 1; 328 } 329 330 static noinline void test_kernel_write_nochange(void) { test_var = 42; } 331 332 /* Suffixed by value-change exception filter. */ 333 static noinline void test_kernel_write_nochange_rcu(void) { test_var = 42; } 334 335 static noinline void test_kernel_read_atomic(void) 336 { 337 sink_value(READ_ONCE(test_var)); 338 } 339 340 static noinline void test_kernel_write_atomic(void) 341 { 342 WRITE_ONCE(test_var, READ_ONCE_NOCHECK(test_sink) + 1); 343 } 344 345 static noinline void test_kernel_atomic_rmw(void) 346 { 347 /* Use builtin, so we can set up the "bad" atomic/non-atomic scenario. */ 348 __atomic_fetch_add(&test_var, 1, __ATOMIC_RELAXED); 349 } 350 351 __no_kcsan 352 static noinline void test_kernel_write_uninstrumented(void) { test_var++; } 353 354 static noinline void test_kernel_data_race(void) { data_race(test_var++); } 355 356 static noinline void test_kernel_assert_writer(void) 357 { 358 ASSERT_EXCLUSIVE_WRITER(test_var); 359 } 360 361 static noinline void test_kernel_assert_access(void) 362 { 363 ASSERT_EXCLUSIVE_ACCESS(test_var); 364 } 365 366 #define TEST_CHANGE_BITS 0xff00ff00 367 368 static noinline void test_kernel_change_bits(void) 369 { 370 if (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) { 371 /* 372 * Avoid race of unknown origin for this test, just pretend they 373 * are atomic. 374 */ 375 kcsan_nestable_atomic_begin(); 376 test_var ^= TEST_CHANGE_BITS; 377 kcsan_nestable_atomic_end(); 378 } else 379 WRITE_ONCE(test_var, READ_ONCE(test_var) ^ TEST_CHANGE_BITS); 380 } 381 382 static noinline void test_kernel_assert_bits_change(void) 383 { 384 ASSERT_EXCLUSIVE_BITS(test_var, TEST_CHANGE_BITS); 385 } 386 387 static noinline void test_kernel_assert_bits_nochange(void) 388 { 389 ASSERT_EXCLUSIVE_BITS(test_var, ~TEST_CHANGE_BITS); 390 } 391 392 /* 393 * Scoped assertions do trigger anywhere in scope. However, the report should 394 * still only point at the start of the scope. 395 */ 396 static noinline void test_enter_scope(void) 397 { 398 int x = 0; 399 400 /* Unrelated accesses to scoped assert. */ 401 READ_ONCE(test_sink); 402 kcsan_check_read(&x, sizeof(x)); 403 } 404 405 static noinline void test_kernel_assert_writer_scoped(void) 406 { 407 ASSERT_EXCLUSIVE_WRITER_SCOPED(test_var); 408 test_enter_scope(); 409 } 410 411 static noinline void test_kernel_assert_access_scoped(void) 412 { 413 ASSERT_EXCLUSIVE_ACCESS_SCOPED(test_var); 414 test_enter_scope(); 415 } 416 417 static noinline void test_kernel_rmw_array(void) 418 { 419 int i; 420 421 for (i = 0; i < ARRAY_SIZE(test_array); ++i) 422 test_array[i]++; 423 } 424 425 static noinline void test_kernel_write_struct(void) 426 { 427 kcsan_check_write(&test_struct, sizeof(test_struct)); 428 kcsan_disable_current(); 429 test_struct.val[3]++; /* induce value change */ 430 kcsan_enable_current(); 431 } 432 433 static noinline void test_kernel_write_struct_part(void) 434 { 435 test_struct.val[3] = 42; 436 } 437 438 static noinline void test_kernel_read_struct_zero_size(void) 439 { 440 kcsan_check_read(&test_struct.val[3], 0); 441 } 442 443 static noinline void test_kernel_jiffies_reader(void) 444 { 445 sink_value((long)jiffies); 446 } 447 448 static noinline void test_kernel_seqlock_reader(void) 449 { 450 unsigned int seq; 451 452 do { 453 seq = read_seqbegin(&test_seqlock); 454 sink_value(test_var); 455 } while (read_seqretry(&test_seqlock, seq)); 456 } 457 458 static noinline void test_kernel_seqlock_writer(void) 459 { 460 unsigned long flags; 461 462 write_seqlock_irqsave(&test_seqlock, flags); 463 test_var++; 464 write_sequnlock_irqrestore(&test_seqlock, flags); 465 } 466 467 static noinline void test_kernel_atomic_builtins(void) 468 { 469 /* 470 * Generate concurrent accesses, expecting no reports, ensuring KCSAN 471 * treats builtin atomics as actually atomic. 472 */ 473 __atomic_load_n(&test_var, __ATOMIC_RELAXED); 474 } 475 476 static noinline void test_kernel_xor_1bit(void) 477 { 478 /* Do not report data races between the read-writes. */ 479 kcsan_nestable_atomic_begin(); 480 test_var ^= 0x10000; 481 kcsan_nestable_atomic_end(); 482 } 483 484 #define TEST_KERNEL_LOCKED(name, acquire, release) \ 485 static noinline void test_kernel_##name(void) \ 486 { \ 487 long *flag = &test_struct.val[0]; \ 488 long v = 0; \ 489 if (!(acquire)) \ 490 return; \ 491 while (v++ < 100) { \ 492 test_var++; \ 493 barrier(); \ 494 } \ 495 release; \ 496 test_delay(10); \ 497 } 498 499 TEST_KERNEL_LOCKED(with_memorder, 500 cmpxchg_acquire(flag, 0, 1) == 0, 501 smp_store_release(flag, 0)); 502 TEST_KERNEL_LOCKED(wrong_memorder, 503 cmpxchg_relaxed(flag, 0, 1) == 0, 504 WRITE_ONCE(*flag, 0)); 505 TEST_KERNEL_LOCKED(atomic_builtin_with_memorder, 506 __atomic_compare_exchange_n(flag, &v, 1, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED), 507 __atomic_store_n(flag, 0, __ATOMIC_RELEASE)); 508 TEST_KERNEL_LOCKED(atomic_builtin_wrong_memorder, 509 __atomic_compare_exchange_n(flag, &v, 1, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED), 510 __atomic_store_n(flag, 0, __ATOMIC_RELAXED)); 511 512 /* ===== Test cases ===== */ 513 514 /* 515 * Tests that various barriers have the expected effect on internal state. Not 516 * exhaustive on atomic_t operations. Unlike the selftest, also checks for 517 * too-strict barrier instrumentation; these can be tolerated, because it does 518 * not cause false positives, but at least we should be aware of such cases. 519 */ 520 static void test_barrier_nothreads(struct kunit *test) 521 { 522 #ifdef CONFIG_KCSAN_WEAK_MEMORY 523 struct kcsan_scoped_access *reorder_access = ¤t->kcsan_ctx.reorder_access; 524 #else 525 struct kcsan_scoped_access *reorder_access = NULL; 526 #endif 527 arch_spinlock_t arch_spinlock = __ARCH_SPIN_LOCK_UNLOCKED; 528 atomic_t dummy; 529 530 KCSAN_TEST_REQUIRES(test, reorder_access != NULL); 531 KCSAN_TEST_REQUIRES(test, IS_ENABLED(CONFIG_SMP)); 532 533 #define __KCSAN_EXPECT_BARRIER(access_type, barrier, order_before, name) \ 534 do { \ 535 reorder_access->type = (access_type) | KCSAN_ACCESS_SCOPED; \ 536 reorder_access->size = sizeof(test_var); \ 537 barrier; \ 538 KUNIT_EXPECT_EQ_MSG(test, reorder_access->size, \ 539 order_before ? 0 : sizeof(test_var), \ 540 "improperly instrumented type=(" #access_type "): " name); \ 541 } while (0) 542 #define KCSAN_EXPECT_READ_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(0, b, o, #b) 543 #define KCSAN_EXPECT_WRITE_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(KCSAN_ACCESS_WRITE, b, o, #b) 544 #define KCSAN_EXPECT_RW_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE, b, o, #b) 545 546 /* 547 * Lockdep initialization can strengthen certain locking operations due 548 * to calling into instrumented files; "warm up" our locks. 549 */ 550 spin_lock(&test_spinlock); 551 spin_unlock(&test_spinlock); 552 mutex_lock(&test_mutex); 553 mutex_unlock(&test_mutex); 554 555 /* Force creating a valid entry in reorder_access first. */ 556 test_var = 0; 557 while (test_var++ < 1000000 && reorder_access->size != sizeof(test_var)) 558 __kcsan_check_read(&test_var, sizeof(test_var)); 559 KUNIT_ASSERT_EQ(test, reorder_access->size, sizeof(test_var)); 560 561 kcsan_nestable_atomic_begin(); /* No watchpoints in called functions. */ 562 563 KCSAN_EXPECT_READ_BARRIER(mb(), true); 564 KCSAN_EXPECT_READ_BARRIER(wmb(), false); 565 KCSAN_EXPECT_READ_BARRIER(rmb(), true); 566 KCSAN_EXPECT_READ_BARRIER(smp_mb(), true); 567 KCSAN_EXPECT_READ_BARRIER(smp_wmb(), false); 568 KCSAN_EXPECT_READ_BARRIER(smp_rmb(), true); 569 KCSAN_EXPECT_READ_BARRIER(dma_wmb(), false); 570 KCSAN_EXPECT_READ_BARRIER(dma_rmb(), true); 571 KCSAN_EXPECT_READ_BARRIER(smp_mb__before_atomic(), true); 572 KCSAN_EXPECT_READ_BARRIER(smp_mb__after_atomic(), true); 573 KCSAN_EXPECT_READ_BARRIER(smp_mb__after_spinlock(), true); 574 KCSAN_EXPECT_READ_BARRIER(smp_store_mb(test_var, 0), true); 575 KCSAN_EXPECT_READ_BARRIER(smp_load_acquire(&test_var), false); 576 KCSAN_EXPECT_READ_BARRIER(smp_store_release(&test_var, 0), true); 577 KCSAN_EXPECT_READ_BARRIER(xchg(&test_var, 0), true); 578 KCSAN_EXPECT_READ_BARRIER(xchg_release(&test_var, 0), true); 579 KCSAN_EXPECT_READ_BARRIER(xchg_relaxed(&test_var, 0), false); 580 KCSAN_EXPECT_READ_BARRIER(cmpxchg(&test_var, 0, 0), true); 581 KCSAN_EXPECT_READ_BARRIER(cmpxchg_release(&test_var, 0, 0), true); 582 KCSAN_EXPECT_READ_BARRIER(cmpxchg_relaxed(&test_var, 0, 0), false); 583 KCSAN_EXPECT_READ_BARRIER(atomic_read(&dummy), false); 584 KCSAN_EXPECT_READ_BARRIER(atomic_read_acquire(&dummy), false); 585 KCSAN_EXPECT_READ_BARRIER(atomic_set(&dummy, 0), false); 586 KCSAN_EXPECT_READ_BARRIER(atomic_set_release(&dummy, 0), true); 587 KCSAN_EXPECT_READ_BARRIER(atomic_add(1, &dummy), false); 588 KCSAN_EXPECT_READ_BARRIER(atomic_add_return(1, &dummy), true); 589 KCSAN_EXPECT_READ_BARRIER(atomic_add_return_acquire(1, &dummy), false); 590 KCSAN_EXPECT_READ_BARRIER(atomic_add_return_release(1, &dummy), true); 591 KCSAN_EXPECT_READ_BARRIER(atomic_add_return_relaxed(1, &dummy), false); 592 KCSAN_EXPECT_READ_BARRIER(atomic_fetch_add(1, &dummy), true); 593 KCSAN_EXPECT_READ_BARRIER(atomic_fetch_add_acquire(1, &dummy), false); 594 KCSAN_EXPECT_READ_BARRIER(atomic_fetch_add_release(1, &dummy), true); 595 KCSAN_EXPECT_READ_BARRIER(atomic_fetch_add_relaxed(1, &dummy), false); 596 KCSAN_EXPECT_READ_BARRIER(test_and_set_bit(0, &test_var), true); 597 KCSAN_EXPECT_READ_BARRIER(test_and_clear_bit(0, &test_var), true); 598 KCSAN_EXPECT_READ_BARRIER(test_and_change_bit(0, &test_var), true); 599 KCSAN_EXPECT_READ_BARRIER(clear_bit_unlock(0, &test_var), true); 600 KCSAN_EXPECT_READ_BARRIER(__clear_bit_unlock(0, &test_var), true); 601 KCSAN_EXPECT_READ_BARRIER(clear_bit_unlock_is_negative_byte(0, &test_var), true); 602 KCSAN_EXPECT_READ_BARRIER(arch_spin_lock(&arch_spinlock), false); 603 KCSAN_EXPECT_READ_BARRIER(arch_spin_unlock(&arch_spinlock), true); 604 KCSAN_EXPECT_READ_BARRIER(spin_lock(&test_spinlock), false); 605 KCSAN_EXPECT_READ_BARRIER(spin_unlock(&test_spinlock), true); 606 KCSAN_EXPECT_READ_BARRIER(mutex_lock(&test_mutex), false); 607 KCSAN_EXPECT_READ_BARRIER(mutex_unlock(&test_mutex), true); 608 609 KCSAN_EXPECT_WRITE_BARRIER(mb(), true); 610 KCSAN_EXPECT_WRITE_BARRIER(wmb(), true); 611 KCSAN_EXPECT_WRITE_BARRIER(rmb(), false); 612 KCSAN_EXPECT_WRITE_BARRIER(smp_mb(), true); 613 KCSAN_EXPECT_WRITE_BARRIER(smp_wmb(), true); 614 KCSAN_EXPECT_WRITE_BARRIER(smp_rmb(), false); 615 KCSAN_EXPECT_WRITE_BARRIER(dma_wmb(), true); 616 KCSAN_EXPECT_WRITE_BARRIER(dma_rmb(), false); 617 KCSAN_EXPECT_WRITE_BARRIER(smp_mb__before_atomic(), true); 618 KCSAN_EXPECT_WRITE_BARRIER(smp_mb__after_atomic(), true); 619 KCSAN_EXPECT_WRITE_BARRIER(smp_mb__after_spinlock(), true); 620 KCSAN_EXPECT_WRITE_BARRIER(smp_store_mb(test_var, 0), true); 621 KCSAN_EXPECT_WRITE_BARRIER(smp_load_acquire(&test_var), false); 622 KCSAN_EXPECT_WRITE_BARRIER(smp_store_release(&test_var, 0), true); 623 KCSAN_EXPECT_WRITE_BARRIER(xchg(&test_var, 0), true); 624 KCSAN_EXPECT_WRITE_BARRIER(xchg_release(&test_var, 0), true); 625 KCSAN_EXPECT_WRITE_BARRIER(xchg_relaxed(&test_var, 0), false); 626 KCSAN_EXPECT_WRITE_BARRIER(cmpxchg(&test_var, 0, 0), true); 627 KCSAN_EXPECT_WRITE_BARRIER(cmpxchg_release(&test_var, 0, 0), true); 628 KCSAN_EXPECT_WRITE_BARRIER(cmpxchg_relaxed(&test_var, 0, 0), false); 629 KCSAN_EXPECT_WRITE_BARRIER(atomic_read(&dummy), false); 630 KCSAN_EXPECT_WRITE_BARRIER(atomic_read_acquire(&dummy), false); 631 KCSAN_EXPECT_WRITE_BARRIER(atomic_set(&dummy, 0), false); 632 KCSAN_EXPECT_WRITE_BARRIER(atomic_set_release(&dummy, 0), true); 633 KCSAN_EXPECT_WRITE_BARRIER(atomic_add(1, &dummy), false); 634 KCSAN_EXPECT_WRITE_BARRIER(atomic_add_return(1, &dummy), true); 635 KCSAN_EXPECT_WRITE_BARRIER(atomic_add_return_acquire(1, &dummy), false); 636 KCSAN_EXPECT_WRITE_BARRIER(atomic_add_return_release(1, &dummy), true); 637 KCSAN_EXPECT_WRITE_BARRIER(atomic_add_return_relaxed(1, &dummy), false); 638 KCSAN_EXPECT_WRITE_BARRIER(atomic_fetch_add(1, &dummy), true); 639 KCSAN_EXPECT_WRITE_BARRIER(atomic_fetch_add_acquire(1, &dummy), false); 640 KCSAN_EXPECT_WRITE_BARRIER(atomic_fetch_add_release(1, &dummy), true); 641 KCSAN_EXPECT_WRITE_BARRIER(atomic_fetch_add_relaxed(1, &dummy), false); 642 KCSAN_EXPECT_WRITE_BARRIER(test_and_set_bit(0, &test_var), true); 643 KCSAN_EXPECT_WRITE_BARRIER(test_and_clear_bit(0, &test_var), true); 644 KCSAN_EXPECT_WRITE_BARRIER(test_and_change_bit(0, &test_var), true); 645 KCSAN_EXPECT_WRITE_BARRIER(clear_bit_unlock(0, &test_var), true); 646 KCSAN_EXPECT_WRITE_BARRIER(__clear_bit_unlock(0, &test_var), true); 647 KCSAN_EXPECT_WRITE_BARRIER(clear_bit_unlock_is_negative_byte(0, &test_var), true); 648 KCSAN_EXPECT_WRITE_BARRIER(arch_spin_lock(&arch_spinlock), false); 649 KCSAN_EXPECT_WRITE_BARRIER(arch_spin_unlock(&arch_spinlock), true); 650 KCSAN_EXPECT_WRITE_BARRIER(spin_lock(&test_spinlock), false); 651 KCSAN_EXPECT_WRITE_BARRIER(spin_unlock(&test_spinlock), true); 652 KCSAN_EXPECT_WRITE_BARRIER(mutex_lock(&test_mutex), false); 653 KCSAN_EXPECT_WRITE_BARRIER(mutex_unlock(&test_mutex), true); 654 655 KCSAN_EXPECT_RW_BARRIER(mb(), true); 656 KCSAN_EXPECT_RW_BARRIER(wmb(), true); 657 KCSAN_EXPECT_RW_BARRIER(rmb(), true); 658 KCSAN_EXPECT_RW_BARRIER(smp_mb(), true); 659 KCSAN_EXPECT_RW_BARRIER(smp_wmb(), true); 660 KCSAN_EXPECT_RW_BARRIER(smp_rmb(), true); 661 KCSAN_EXPECT_RW_BARRIER(dma_wmb(), true); 662 KCSAN_EXPECT_RW_BARRIER(dma_rmb(), true); 663 KCSAN_EXPECT_RW_BARRIER(smp_mb__before_atomic(), true); 664 KCSAN_EXPECT_RW_BARRIER(smp_mb__after_atomic(), true); 665 KCSAN_EXPECT_RW_BARRIER(smp_mb__after_spinlock(), true); 666 KCSAN_EXPECT_RW_BARRIER(smp_store_mb(test_var, 0), true); 667 KCSAN_EXPECT_RW_BARRIER(smp_load_acquire(&test_var), false); 668 KCSAN_EXPECT_RW_BARRIER(smp_store_release(&test_var, 0), true); 669 KCSAN_EXPECT_RW_BARRIER(xchg(&test_var, 0), true); 670 KCSAN_EXPECT_RW_BARRIER(xchg_release(&test_var, 0), true); 671 KCSAN_EXPECT_RW_BARRIER(xchg_relaxed(&test_var, 0), false); 672 KCSAN_EXPECT_RW_BARRIER(cmpxchg(&test_var, 0, 0), true); 673 KCSAN_EXPECT_RW_BARRIER(cmpxchg_release(&test_var, 0, 0), true); 674 KCSAN_EXPECT_RW_BARRIER(cmpxchg_relaxed(&test_var, 0, 0), false); 675 KCSAN_EXPECT_RW_BARRIER(atomic_read(&dummy), false); 676 KCSAN_EXPECT_RW_BARRIER(atomic_read_acquire(&dummy), false); 677 KCSAN_EXPECT_RW_BARRIER(atomic_set(&dummy, 0), false); 678 KCSAN_EXPECT_RW_BARRIER(atomic_set_release(&dummy, 0), true); 679 KCSAN_EXPECT_RW_BARRIER(atomic_add(1, &dummy), false); 680 KCSAN_EXPECT_RW_BARRIER(atomic_add_return(1, &dummy), true); 681 KCSAN_EXPECT_RW_BARRIER(atomic_add_return_acquire(1, &dummy), false); 682 KCSAN_EXPECT_RW_BARRIER(atomic_add_return_release(1, &dummy), true); 683 KCSAN_EXPECT_RW_BARRIER(atomic_add_return_relaxed(1, &dummy), false); 684 KCSAN_EXPECT_RW_BARRIER(atomic_fetch_add(1, &dummy), true); 685 KCSAN_EXPECT_RW_BARRIER(atomic_fetch_add_acquire(1, &dummy), false); 686 KCSAN_EXPECT_RW_BARRIER(atomic_fetch_add_release(1, &dummy), true); 687 KCSAN_EXPECT_RW_BARRIER(atomic_fetch_add_relaxed(1, &dummy), false); 688 KCSAN_EXPECT_RW_BARRIER(test_and_set_bit(0, &test_var), true); 689 KCSAN_EXPECT_RW_BARRIER(test_and_clear_bit(0, &test_var), true); 690 KCSAN_EXPECT_RW_BARRIER(test_and_change_bit(0, &test_var), true); 691 KCSAN_EXPECT_RW_BARRIER(clear_bit_unlock(0, &test_var), true); 692 KCSAN_EXPECT_RW_BARRIER(__clear_bit_unlock(0, &test_var), true); 693 KCSAN_EXPECT_RW_BARRIER(clear_bit_unlock_is_negative_byte(0, &test_var), true); 694 KCSAN_EXPECT_RW_BARRIER(arch_spin_lock(&arch_spinlock), false); 695 KCSAN_EXPECT_RW_BARRIER(arch_spin_unlock(&arch_spinlock), true); 696 KCSAN_EXPECT_RW_BARRIER(spin_lock(&test_spinlock), false); 697 KCSAN_EXPECT_RW_BARRIER(spin_unlock(&test_spinlock), true); 698 KCSAN_EXPECT_RW_BARRIER(mutex_lock(&test_mutex), false); 699 KCSAN_EXPECT_RW_BARRIER(mutex_unlock(&test_mutex), true); 700 701 kcsan_nestable_atomic_end(); 702 } 703 704 /* Simple test with normal data race. */ 705 __no_kcsan 706 static void test_basic(struct kunit *test) 707 { 708 struct expect_report expect = { 709 .access = { 710 { test_kernel_write, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 711 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 712 }, 713 }; 714 struct expect_report never = { 715 .access = { 716 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 717 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 718 }, 719 }; 720 bool match_expect = false; 721 bool match_never = false; 722 723 begin_test_checks(test_kernel_write, test_kernel_read); 724 do { 725 match_expect |= report_matches(&expect); 726 match_never = report_matches(&never); 727 } while (!end_test_checks(match_never)); 728 KUNIT_EXPECT_TRUE(test, match_expect); 729 KUNIT_EXPECT_FALSE(test, match_never); 730 } 731 732 /* 733 * Stress KCSAN with lots of concurrent races on different addresses until 734 * timeout. 735 */ 736 __no_kcsan 737 static void test_concurrent_races(struct kunit *test) 738 { 739 struct expect_report expect = { 740 .access = { 741 /* NULL will match any address. */ 742 { test_kernel_rmw_array, NULL, 0, __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 743 { test_kernel_rmw_array, NULL, 0, __KCSAN_ACCESS_RW(0) }, 744 }, 745 }; 746 struct expect_report never = { 747 .access = { 748 { test_kernel_rmw_array, NULL, 0, 0 }, 749 { test_kernel_rmw_array, NULL, 0, 0 }, 750 }, 751 }; 752 bool match_expect = false; 753 bool match_never = false; 754 755 begin_test_checks(test_kernel_rmw_array, test_kernel_rmw_array); 756 do { 757 match_expect |= report_matches(&expect); 758 match_never |= report_matches(&never); 759 } while (!end_test_checks(false)); 760 KUNIT_EXPECT_TRUE(test, match_expect); /* Sanity check matches exist. */ 761 KUNIT_EXPECT_FALSE(test, match_never); 762 } 763 764 /* Test the KCSAN_REPORT_VALUE_CHANGE_ONLY option. */ 765 __no_kcsan 766 static void test_novalue_change(struct kunit *test) 767 { 768 struct expect_report expect_rw = { 769 .access = { 770 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 771 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 772 }, 773 }; 774 struct expect_report expect_ww = { 775 .access = { 776 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 777 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 778 }, 779 }; 780 bool match_expect = false; 781 782 test_kernel_write_nochange(); /* Reset value. */ 783 begin_test_checks(test_kernel_write_nochange, test_kernel_read); 784 do { 785 match_expect = report_matches(&expect_rw) || report_matches(&expect_ww); 786 } while (!end_test_checks(match_expect)); 787 if (IS_ENABLED(CONFIG_KCSAN_REPORT_VALUE_CHANGE_ONLY)) 788 KUNIT_EXPECT_FALSE(test, match_expect); 789 else 790 KUNIT_EXPECT_TRUE(test, match_expect); 791 } 792 793 /* 794 * Test that the rules where the KCSAN_REPORT_VALUE_CHANGE_ONLY option should 795 * never apply work. 796 */ 797 __no_kcsan 798 static void test_novalue_change_exception(struct kunit *test) 799 { 800 struct expect_report expect_rw = { 801 .access = { 802 { test_kernel_write_nochange_rcu, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 803 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 804 }, 805 }; 806 struct expect_report expect_ww = { 807 .access = { 808 { test_kernel_write_nochange_rcu, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 809 { test_kernel_write_nochange_rcu, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 810 }, 811 }; 812 bool match_expect = false; 813 814 test_kernel_write_nochange_rcu(); /* Reset value. */ 815 begin_test_checks(test_kernel_write_nochange_rcu, test_kernel_read); 816 do { 817 match_expect = report_matches(&expect_rw) || report_matches(&expect_ww); 818 } while (!end_test_checks(match_expect)); 819 KUNIT_EXPECT_TRUE(test, match_expect); 820 } 821 822 /* Test that data races of unknown origin are reported. */ 823 __no_kcsan 824 static void test_unknown_origin(struct kunit *test) 825 { 826 struct expect_report expect = { 827 .access = { 828 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 829 { NULL }, 830 }, 831 }; 832 bool match_expect = false; 833 834 begin_test_checks(test_kernel_write_uninstrumented, test_kernel_read); 835 do { 836 match_expect = report_matches(&expect); 837 } while (!end_test_checks(match_expect)); 838 if (IS_ENABLED(CONFIG_KCSAN_REPORT_RACE_UNKNOWN_ORIGIN)) 839 KUNIT_EXPECT_TRUE(test, match_expect); 840 else 841 KUNIT_EXPECT_FALSE(test, match_expect); 842 } 843 844 /* Test KCSAN_ASSUME_PLAIN_WRITES_ATOMIC if it is selected. */ 845 __no_kcsan 846 static void test_write_write_assume_atomic(struct kunit *test) 847 { 848 struct expect_report expect = { 849 .access = { 850 { test_kernel_write, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 851 { test_kernel_write, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 852 }, 853 }; 854 bool match_expect = false; 855 856 begin_test_checks(test_kernel_write, test_kernel_write); 857 do { 858 sink_value(READ_ONCE(test_var)); /* induce value-change */ 859 match_expect = report_matches(&expect); 860 } while (!end_test_checks(match_expect)); 861 if (IS_ENABLED(CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC)) 862 KUNIT_EXPECT_FALSE(test, match_expect); 863 else 864 KUNIT_EXPECT_TRUE(test, match_expect); 865 } 866 867 /* 868 * Test that data races with writes larger than word-size are always reported, 869 * even if KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected. 870 */ 871 __no_kcsan 872 static void test_write_write_struct(struct kunit *test) 873 { 874 struct expect_report expect = { 875 .access = { 876 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 877 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 878 }, 879 }; 880 bool match_expect = false; 881 882 begin_test_checks(test_kernel_write_struct, test_kernel_write_struct); 883 do { 884 match_expect = report_matches(&expect); 885 } while (!end_test_checks(match_expect)); 886 KUNIT_EXPECT_TRUE(test, match_expect); 887 } 888 889 /* 890 * Test that data races where only one write is larger than word-size are always 891 * reported, even if KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected. 892 */ 893 __no_kcsan 894 static void test_write_write_struct_part(struct kunit *test) 895 { 896 struct expect_report expect = { 897 .access = { 898 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 899 { test_kernel_write_struct_part, &test_struct.val[3], sizeof(test_struct.val[3]), KCSAN_ACCESS_WRITE }, 900 }, 901 }; 902 bool match_expect = false; 903 904 begin_test_checks(test_kernel_write_struct, test_kernel_write_struct_part); 905 do { 906 match_expect = report_matches(&expect); 907 } while (!end_test_checks(match_expect)); 908 KUNIT_EXPECT_TRUE(test, match_expect); 909 } 910 911 /* Test that races with atomic accesses never result in reports. */ 912 __no_kcsan 913 static void test_read_atomic_write_atomic(struct kunit *test) 914 { 915 bool match_never = false; 916 917 begin_test_checks(test_kernel_read_atomic, test_kernel_write_atomic); 918 do { 919 match_never = report_available(); 920 } while (!end_test_checks(match_never)); 921 KUNIT_EXPECT_FALSE(test, match_never); 922 } 923 924 /* Test that a race with an atomic and plain access result in reports. */ 925 __no_kcsan 926 static void test_read_plain_atomic_write(struct kunit *test) 927 { 928 struct expect_report expect = { 929 .access = { 930 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 931 { test_kernel_write_atomic, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC }, 932 }, 933 }; 934 bool match_expect = false; 935 936 KCSAN_TEST_REQUIRES(test, !IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)); 937 938 begin_test_checks(test_kernel_read, test_kernel_write_atomic); 939 do { 940 match_expect = report_matches(&expect); 941 } while (!end_test_checks(match_expect)); 942 KUNIT_EXPECT_TRUE(test, match_expect); 943 } 944 945 /* Test that atomic RMWs generate correct report. */ 946 __no_kcsan 947 static void test_read_plain_atomic_rmw(struct kunit *test) 948 { 949 struct expect_report expect = { 950 .access = { 951 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 952 { test_kernel_atomic_rmw, &test_var, sizeof(test_var), 953 KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC }, 954 }, 955 }; 956 bool match_expect = false; 957 958 KCSAN_TEST_REQUIRES(test, !IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)); 959 960 begin_test_checks(test_kernel_read, test_kernel_atomic_rmw); 961 do { 962 match_expect = report_matches(&expect); 963 } while (!end_test_checks(match_expect)); 964 KUNIT_EXPECT_TRUE(test, match_expect); 965 } 966 967 /* Zero-sized accesses should never cause data race reports. */ 968 __no_kcsan 969 static void test_zero_size_access(struct kunit *test) 970 { 971 struct expect_report expect = { 972 .access = { 973 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 974 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 975 }, 976 }; 977 struct expect_report never = { 978 .access = { 979 { test_kernel_write_struct, &test_struct, sizeof(test_struct), KCSAN_ACCESS_WRITE }, 980 { test_kernel_read_struct_zero_size, &test_struct.val[3], 0, 0 }, 981 }, 982 }; 983 bool match_expect = false; 984 bool match_never = false; 985 986 begin_test_checks(test_kernel_write_struct, test_kernel_read_struct_zero_size); 987 do { 988 match_expect |= report_matches(&expect); 989 match_never = report_matches(&never); 990 } while (!end_test_checks(match_never)); 991 KUNIT_EXPECT_TRUE(test, match_expect); /* Sanity check. */ 992 KUNIT_EXPECT_FALSE(test, match_never); 993 } 994 995 /* Test the data_race() macro. */ 996 __no_kcsan 997 static void test_data_race(struct kunit *test) 998 { 999 bool match_never = false; 1000 1001 begin_test_checks(test_kernel_data_race, test_kernel_data_race); 1002 do { 1003 match_never = report_available(); 1004 } while (!end_test_checks(match_never)); 1005 KUNIT_EXPECT_FALSE(test, match_never); 1006 } 1007 1008 __no_kcsan 1009 static void test_assert_exclusive_writer(struct kunit *test) 1010 { 1011 struct expect_report expect = { 1012 .access = { 1013 { test_kernel_assert_writer, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT }, 1014 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 1015 }, 1016 }; 1017 bool match_expect = false; 1018 1019 begin_test_checks(test_kernel_assert_writer, test_kernel_write_nochange); 1020 do { 1021 match_expect = report_matches(&expect); 1022 } while (!end_test_checks(match_expect)); 1023 KUNIT_EXPECT_TRUE(test, match_expect); 1024 } 1025 1026 __no_kcsan 1027 static void test_assert_exclusive_access(struct kunit *test) 1028 { 1029 struct expect_report expect = { 1030 .access = { 1031 { test_kernel_assert_access, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE }, 1032 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 1033 }, 1034 }; 1035 bool match_expect = false; 1036 1037 begin_test_checks(test_kernel_assert_access, test_kernel_read); 1038 do { 1039 match_expect = report_matches(&expect); 1040 } while (!end_test_checks(match_expect)); 1041 KUNIT_EXPECT_TRUE(test, match_expect); 1042 } 1043 1044 __no_kcsan 1045 static void test_assert_exclusive_access_writer(struct kunit *test) 1046 { 1047 struct expect_report expect_access_writer = { 1048 .access = { 1049 { test_kernel_assert_access, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE }, 1050 { test_kernel_assert_writer, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT }, 1051 }, 1052 }; 1053 struct expect_report expect_access_access = { 1054 .access = { 1055 { test_kernel_assert_access, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE }, 1056 { test_kernel_assert_access, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE }, 1057 }, 1058 }; 1059 struct expect_report never = { 1060 .access = { 1061 { test_kernel_assert_writer, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT }, 1062 { test_kernel_assert_writer, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT }, 1063 }, 1064 }; 1065 bool match_expect_access_writer = false; 1066 bool match_expect_access_access = false; 1067 bool match_never = false; 1068 1069 begin_test_checks(test_kernel_assert_access, test_kernel_assert_writer); 1070 do { 1071 match_expect_access_writer |= report_matches(&expect_access_writer); 1072 match_expect_access_access |= report_matches(&expect_access_access); 1073 match_never |= report_matches(&never); 1074 } while (!end_test_checks(match_never)); 1075 KUNIT_EXPECT_TRUE(test, match_expect_access_writer); 1076 KUNIT_EXPECT_TRUE(test, match_expect_access_access); 1077 KUNIT_EXPECT_FALSE(test, match_never); 1078 } 1079 1080 __no_kcsan 1081 static void test_assert_exclusive_bits_change(struct kunit *test) 1082 { 1083 struct expect_report expect = { 1084 .access = { 1085 { test_kernel_assert_bits_change, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT }, 1086 { test_kernel_change_bits, &test_var, sizeof(test_var), 1087 KCSAN_ACCESS_WRITE | (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS) ? 0 : KCSAN_ACCESS_ATOMIC) }, 1088 }, 1089 }; 1090 bool match_expect = false; 1091 1092 begin_test_checks(test_kernel_assert_bits_change, test_kernel_change_bits); 1093 do { 1094 match_expect = report_matches(&expect); 1095 } while (!end_test_checks(match_expect)); 1096 KUNIT_EXPECT_TRUE(test, match_expect); 1097 } 1098 1099 __no_kcsan 1100 static void test_assert_exclusive_bits_nochange(struct kunit *test) 1101 { 1102 bool match_never = false; 1103 1104 begin_test_checks(test_kernel_assert_bits_nochange, test_kernel_change_bits); 1105 do { 1106 match_never = report_available(); 1107 } while (!end_test_checks(match_never)); 1108 KUNIT_EXPECT_FALSE(test, match_never); 1109 } 1110 1111 __no_kcsan 1112 static void test_assert_exclusive_writer_scoped(struct kunit *test) 1113 { 1114 struct expect_report expect_start = { 1115 .access = { 1116 { test_kernel_assert_writer_scoped, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_SCOPED }, 1117 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 1118 }, 1119 }; 1120 struct expect_report expect_inscope = { 1121 .access = { 1122 { test_enter_scope, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_SCOPED }, 1123 { test_kernel_write_nochange, &test_var, sizeof(test_var), KCSAN_ACCESS_WRITE }, 1124 }, 1125 }; 1126 bool match_expect_start = false; 1127 bool match_expect_inscope = false; 1128 1129 begin_test_checks(test_kernel_assert_writer_scoped, test_kernel_write_nochange); 1130 do { 1131 match_expect_start |= report_matches(&expect_start); 1132 match_expect_inscope |= report_matches(&expect_inscope); 1133 } while (!end_test_checks(match_expect_inscope)); 1134 KUNIT_EXPECT_TRUE(test, match_expect_start); 1135 KUNIT_EXPECT_FALSE(test, match_expect_inscope); 1136 } 1137 1138 __no_kcsan 1139 static void test_assert_exclusive_access_scoped(struct kunit *test) 1140 { 1141 struct expect_report expect_start1 = { 1142 .access = { 1143 { test_kernel_assert_access_scoped, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_SCOPED }, 1144 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 1145 }, 1146 }; 1147 struct expect_report expect_start2 = { 1148 .access = { expect_start1.access[0], expect_start1.access[0] }, 1149 }; 1150 struct expect_report expect_inscope = { 1151 .access = { 1152 { test_enter_scope, &test_var, sizeof(test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_SCOPED }, 1153 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 1154 }, 1155 }; 1156 bool match_expect_start = false; 1157 bool match_expect_inscope = false; 1158 1159 begin_test_checks(test_kernel_assert_access_scoped, test_kernel_read); 1160 end_time += msecs_to_jiffies(1000); /* This test requires a bit more time. */ 1161 do { 1162 match_expect_start |= report_matches(&expect_start1) || report_matches(&expect_start2); 1163 match_expect_inscope |= report_matches(&expect_inscope); 1164 } while (!end_test_checks(match_expect_inscope)); 1165 KUNIT_EXPECT_TRUE(test, match_expect_start); 1166 KUNIT_EXPECT_FALSE(test, match_expect_inscope); 1167 } 1168 1169 /* 1170 * jiffies is special (declared to be volatile) and its accesses are typically 1171 * not marked; this test ensures that the compiler nor KCSAN gets confused about 1172 * jiffies's declaration on different architectures. 1173 */ 1174 __no_kcsan 1175 static void test_jiffies_noreport(struct kunit *test) 1176 { 1177 bool match_never = false; 1178 1179 begin_test_checks(test_kernel_jiffies_reader, test_kernel_jiffies_reader); 1180 do { 1181 match_never = report_available(); 1182 } while (!end_test_checks(match_never)); 1183 KUNIT_EXPECT_FALSE(test, match_never); 1184 } 1185 1186 /* Test that racing accesses in seqlock critical sections are not reported. */ 1187 __no_kcsan 1188 static void test_seqlock_noreport(struct kunit *test) 1189 { 1190 bool match_never = false; 1191 1192 begin_test_checks(test_kernel_seqlock_reader, test_kernel_seqlock_writer); 1193 do { 1194 match_never = report_available(); 1195 } while (!end_test_checks(match_never)); 1196 KUNIT_EXPECT_FALSE(test, match_never); 1197 } 1198 1199 /* 1200 * Test atomic builtins work and required instrumentation functions exist. We 1201 * also test that KCSAN understands they're atomic by racing with them via 1202 * test_kernel_atomic_builtins(), and expect no reports. 1203 * 1204 * The atomic builtins _SHOULD NOT_ be used in normal kernel code! 1205 */ 1206 static void test_atomic_builtins(struct kunit *test) 1207 { 1208 bool match_never = false; 1209 1210 begin_test_checks(test_kernel_atomic_builtins, test_kernel_atomic_builtins); 1211 do { 1212 long tmp; 1213 1214 kcsan_enable_current(); 1215 1216 __atomic_store_n(&test_var, 42L, __ATOMIC_RELAXED); 1217 KUNIT_EXPECT_EQ(test, 42L, __atomic_load_n(&test_var, __ATOMIC_RELAXED)); 1218 1219 KUNIT_EXPECT_EQ(test, 42L, __atomic_exchange_n(&test_var, 20, __ATOMIC_RELAXED)); 1220 KUNIT_EXPECT_EQ(test, 20L, test_var); 1221 1222 tmp = 20L; 1223 KUNIT_EXPECT_TRUE(test, __atomic_compare_exchange_n(&test_var, &tmp, 30L, 1224 0, __ATOMIC_RELAXED, 1225 __ATOMIC_RELAXED)); 1226 KUNIT_EXPECT_EQ(test, tmp, 20L); 1227 KUNIT_EXPECT_EQ(test, test_var, 30L); 1228 KUNIT_EXPECT_FALSE(test, __atomic_compare_exchange_n(&test_var, &tmp, 40L, 1229 1, __ATOMIC_RELAXED, 1230 __ATOMIC_RELAXED)); 1231 KUNIT_EXPECT_EQ(test, tmp, 30L); 1232 KUNIT_EXPECT_EQ(test, test_var, 30L); 1233 1234 KUNIT_EXPECT_EQ(test, 30L, __atomic_fetch_add(&test_var, 1, __ATOMIC_RELAXED)); 1235 KUNIT_EXPECT_EQ(test, 31L, __atomic_fetch_sub(&test_var, 1, __ATOMIC_RELAXED)); 1236 KUNIT_EXPECT_EQ(test, 30L, __atomic_fetch_and(&test_var, 0xf, __ATOMIC_RELAXED)); 1237 KUNIT_EXPECT_EQ(test, 14L, __atomic_fetch_xor(&test_var, 0xf, __ATOMIC_RELAXED)); 1238 KUNIT_EXPECT_EQ(test, 1L, __atomic_fetch_or(&test_var, 0xf0, __ATOMIC_RELAXED)); 1239 KUNIT_EXPECT_EQ(test, 241L, __atomic_fetch_nand(&test_var, 0xf, __ATOMIC_RELAXED)); 1240 KUNIT_EXPECT_EQ(test, -2L, test_var); 1241 1242 __atomic_thread_fence(__ATOMIC_SEQ_CST); 1243 __atomic_signal_fence(__ATOMIC_SEQ_CST); 1244 1245 kcsan_disable_current(); 1246 1247 match_never = report_available(); 1248 } while (!end_test_checks(match_never)); 1249 KUNIT_EXPECT_FALSE(test, match_never); 1250 } 1251 1252 __no_kcsan 1253 static void test_1bit_value_change(struct kunit *test) 1254 { 1255 struct expect_report expect = { 1256 .access = { 1257 { test_kernel_read, &test_var, sizeof(test_var), 0 }, 1258 { test_kernel_xor_1bit, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 1259 }, 1260 }; 1261 bool match = false; 1262 1263 begin_test_checks(test_kernel_read, test_kernel_xor_1bit); 1264 do { 1265 match = IS_ENABLED(CONFIG_KCSAN_PERMISSIVE) 1266 ? report_available() 1267 : report_matches(&expect); 1268 } while (!end_test_checks(match)); 1269 if (IS_ENABLED(CONFIG_KCSAN_PERMISSIVE)) 1270 KUNIT_EXPECT_FALSE(test, match); 1271 else 1272 KUNIT_EXPECT_TRUE(test, match); 1273 } 1274 1275 __no_kcsan 1276 static void test_correct_barrier(struct kunit *test) 1277 { 1278 struct expect_report expect = { 1279 .access = { 1280 { test_kernel_with_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 1281 { test_kernel_with_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(0) }, 1282 }, 1283 }; 1284 bool match_expect = false; 1285 1286 test_struct.val[0] = 0; /* init unlocked */ 1287 begin_test_checks(test_kernel_with_memorder, test_kernel_with_memorder); 1288 do { 1289 match_expect = report_matches_any_reordered(&expect); 1290 } while (!end_test_checks(match_expect)); 1291 KUNIT_EXPECT_FALSE(test, match_expect); 1292 } 1293 1294 __no_kcsan 1295 static void test_missing_barrier(struct kunit *test) 1296 { 1297 struct expect_report expect = { 1298 .access = { 1299 { test_kernel_wrong_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 1300 { test_kernel_wrong_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(0) }, 1301 }, 1302 }; 1303 bool match_expect = false; 1304 1305 test_struct.val[0] = 0; /* init unlocked */ 1306 begin_test_checks(test_kernel_wrong_memorder, test_kernel_wrong_memorder); 1307 do { 1308 match_expect = report_matches_any_reordered(&expect); 1309 } while (!end_test_checks(match_expect)); 1310 if (IS_ENABLED(CONFIG_KCSAN_WEAK_MEMORY)) 1311 KUNIT_EXPECT_TRUE(test, match_expect); 1312 else 1313 KUNIT_EXPECT_FALSE(test, match_expect); 1314 } 1315 1316 __no_kcsan 1317 static void test_atomic_builtins_correct_barrier(struct kunit *test) 1318 { 1319 struct expect_report expect = { 1320 .access = { 1321 { test_kernel_atomic_builtin_with_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 1322 { test_kernel_atomic_builtin_with_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(0) }, 1323 }, 1324 }; 1325 bool match_expect = false; 1326 1327 test_struct.val[0] = 0; /* init unlocked */ 1328 begin_test_checks(test_kernel_atomic_builtin_with_memorder, 1329 test_kernel_atomic_builtin_with_memorder); 1330 do { 1331 match_expect = report_matches_any_reordered(&expect); 1332 } while (!end_test_checks(match_expect)); 1333 KUNIT_EXPECT_FALSE(test, match_expect); 1334 } 1335 1336 __no_kcsan 1337 static void test_atomic_builtins_missing_barrier(struct kunit *test) 1338 { 1339 struct expect_report expect = { 1340 .access = { 1341 { test_kernel_atomic_builtin_wrong_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) }, 1342 { test_kernel_atomic_builtin_wrong_memorder, &test_var, sizeof(test_var), __KCSAN_ACCESS_RW(0) }, 1343 }, 1344 }; 1345 bool match_expect = false; 1346 1347 test_struct.val[0] = 0; /* init unlocked */ 1348 begin_test_checks(test_kernel_atomic_builtin_wrong_memorder, 1349 test_kernel_atomic_builtin_wrong_memorder); 1350 do { 1351 match_expect = report_matches_any_reordered(&expect); 1352 } while (!end_test_checks(match_expect)); 1353 if (IS_ENABLED(CONFIG_KCSAN_WEAK_MEMORY)) 1354 KUNIT_EXPECT_TRUE(test, match_expect); 1355 else 1356 KUNIT_EXPECT_FALSE(test, match_expect); 1357 } 1358 1359 /* 1360 * Generate thread counts for all test cases. Values generated are in interval 1361 * [2, 5] followed by exponentially increasing thread counts from 8 to 32. 1362 * 1363 * The thread counts are chosen to cover potentially interesting boundaries and 1364 * corner cases (2 to 5), and then stress the system with larger counts. 1365 */ 1366 static const void *nthreads_gen_params(const void *prev, char *desc) 1367 { 1368 long nthreads = (long)prev; 1369 1370 if (nthreads < 0 || nthreads >= 32) 1371 nthreads = 0; /* stop */ 1372 else if (!nthreads) 1373 nthreads = 2; /* initial value */ 1374 else if (nthreads < 5) 1375 nthreads++; 1376 else if (nthreads == 5) 1377 nthreads = 8; 1378 else 1379 nthreads *= 2; 1380 1381 if (!IS_ENABLED(CONFIG_PREEMPT) || !IS_ENABLED(CONFIG_KCSAN_INTERRUPT_WATCHER)) { 1382 /* 1383 * Without any preemption, keep 2 CPUs free for other tasks, one 1384 * of which is the main test case function checking for 1385 * completion or failure. 1386 */ 1387 const long min_unused_cpus = IS_ENABLED(CONFIG_PREEMPT_NONE) ? 2 : 0; 1388 const long min_required_cpus = 2 + min_unused_cpus; 1389 1390 if (num_online_cpus() < min_required_cpus) { 1391 pr_err_once("Too few online CPUs (%u < %ld) for test\n", 1392 num_online_cpus(), min_required_cpus); 1393 nthreads = 0; 1394 } else if (nthreads >= num_online_cpus() - min_unused_cpus) { 1395 /* Use negative value to indicate last param. */ 1396 nthreads = -(num_online_cpus() - min_unused_cpus); 1397 pr_warn_once("Limiting number of threads to %ld (only %d online CPUs)\n", 1398 -nthreads, num_online_cpus()); 1399 } 1400 } 1401 1402 snprintf(desc, KUNIT_PARAM_DESC_SIZE, "threads=%ld", abs(nthreads)); 1403 return (void *)nthreads; 1404 } 1405 1406 #define KCSAN_KUNIT_CASE(test_name) KUNIT_CASE_PARAM(test_name, nthreads_gen_params) 1407 static struct kunit_case kcsan_test_cases[] = { 1408 KUNIT_CASE(test_barrier_nothreads), 1409 KCSAN_KUNIT_CASE(test_basic), 1410 KCSAN_KUNIT_CASE(test_concurrent_races), 1411 KCSAN_KUNIT_CASE(test_novalue_change), 1412 KCSAN_KUNIT_CASE(test_novalue_change_exception), 1413 KCSAN_KUNIT_CASE(test_unknown_origin), 1414 KCSAN_KUNIT_CASE(test_write_write_assume_atomic), 1415 KCSAN_KUNIT_CASE(test_write_write_struct), 1416 KCSAN_KUNIT_CASE(test_write_write_struct_part), 1417 KCSAN_KUNIT_CASE(test_read_atomic_write_atomic), 1418 KCSAN_KUNIT_CASE(test_read_plain_atomic_write), 1419 KCSAN_KUNIT_CASE(test_read_plain_atomic_rmw), 1420 KCSAN_KUNIT_CASE(test_zero_size_access), 1421 KCSAN_KUNIT_CASE(test_data_race), 1422 KCSAN_KUNIT_CASE(test_assert_exclusive_writer), 1423 KCSAN_KUNIT_CASE(test_assert_exclusive_access), 1424 KCSAN_KUNIT_CASE(test_assert_exclusive_access_writer), 1425 KCSAN_KUNIT_CASE(test_assert_exclusive_bits_change), 1426 KCSAN_KUNIT_CASE(test_assert_exclusive_bits_nochange), 1427 KCSAN_KUNIT_CASE(test_assert_exclusive_writer_scoped), 1428 KCSAN_KUNIT_CASE(test_assert_exclusive_access_scoped), 1429 KCSAN_KUNIT_CASE(test_jiffies_noreport), 1430 KCSAN_KUNIT_CASE(test_seqlock_noreport), 1431 KCSAN_KUNIT_CASE(test_atomic_builtins), 1432 KCSAN_KUNIT_CASE(test_1bit_value_change), 1433 KCSAN_KUNIT_CASE(test_correct_barrier), 1434 KCSAN_KUNIT_CASE(test_missing_barrier), 1435 KCSAN_KUNIT_CASE(test_atomic_builtins_correct_barrier), 1436 KCSAN_KUNIT_CASE(test_atomic_builtins_missing_barrier), 1437 {}, 1438 }; 1439 1440 /* ===== End test cases ===== */ 1441 1442 /* Concurrent accesses from interrupts. */ 1443 __no_kcsan 1444 static void access_thread_timer(struct timer_list *timer) 1445 { 1446 static atomic_t cnt = ATOMIC_INIT(0); 1447 unsigned int idx; 1448 void (*func)(void); 1449 1450 idx = (unsigned int)atomic_inc_return(&cnt) % ARRAY_SIZE(access_kernels); 1451 /* Acquire potential initialization. */ 1452 func = smp_load_acquire(&access_kernels[idx]); 1453 if (func) 1454 func(); 1455 } 1456 1457 /* The main loop for each thread. */ 1458 __no_kcsan 1459 static int access_thread(void *arg) 1460 { 1461 struct timer_list timer; 1462 unsigned int cnt = 0; 1463 unsigned int idx; 1464 void (*func)(void); 1465 1466 timer_setup_on_stack(&timer, access_thread_timer, 0); 1467 do { 1468 might_sleep(); 1469 1470 if (!timer_pending(&timer)) 1471 mod_timer(&timer, jiffies + 1); 1472 else { 1473 /* Iterate through all kernels. */ 1474 idx = cnt++ % ARRAY_SIZE(access_kernels); 1475 /* Acquire potential initialization. */ 1476 func = smp_load_acquire(&access_kernels[idx]); 1477 if (func) 1478 func(); 1479 } 1480 } while (!torture_must_stop()); 1481 del_timer_sync(&timer); 1482 destroy_timer_on_stack(&timer); 1483 1484 torture_kthread_stopping("access_thread"); 1485 return 0; 1486 } 1487 1488 __no_kcsan 1489 static int test_init(struct kunit *test) 1490 { 1491 unsigned long flags; 1492 int nthreads; 1493 int i; 1494 1495 spin_lock_irqsave(&observed.lock, flags); 1496 for (i = 0; i < ARRAY_SIZE(observed.lines); ++i) 1497 observed.lines[i][0] = '\0'; 1498 observed.nlines = 0; 1499 spin_unlock_irqrestore(&observed.lock, flags); 1500 1501 if (strstr(test->name, "nothreads")) 1502 return 0; 1503 1504 if (!torture_init_begin((char *)test->name, 1)) 1505 return -EBUSY; 1506 1507 if (WARN_ON(threads)) 1508 goto err; 1509 1510 for (i = 0; i < ARRAY_SIZE(access_kernels); ++i) { 1511 if (WARN_ON(access_kernels[i])) 1512 goto err; 1513 } 1514 1515 nthreads = abs((long)test->param_value); 1516 if (WARN_ON(!nthreads)) 1517 goto err; 1518 1519 threads = kcalloc(nthreads + 1, sizeof(struct task_struct *), GFP_KERNEL); 1520 if (WARN_ON(!threads)) 1521 goto err; 1522 1523 threads[nthreads] = NULL; 1524 for (i = 0; i < nthreads; ++i) { 1525 if (torture_create_kthread(access_thread, NULL, threads[i])) 1526 goto err; 1527 } 1528 1529 torture_init_end(); 1530 1531 return 0; 1532 1533 err: 1534 kfree(threads); 1535 threads = NULL; 1536 torture_init_end(); 1537 return -EINVAL; 1538 } 1539 1540 __no_kcsan 1541 static void test_exit(struct kunit *test) 1542 { 1543 struct task_struct **stop_thread; 1544 int i; 1545 1546 if (strstr(test->name, "nothreads")) 1547 return; 1548 1549 if (torture_cleanup_begin()) 1550 return; 1551 1552 for (i = 0; i < ARRAY_SIZE(access_kernels); ++i) 1553 WRITE_ONCE(access_kernels[i], NULL); 1554 1555 if (threads) { 1556 for (stop_thread = threads; *stop_thread; stop_thread++) 1557 torture_stop_kthread(reader_thread, *stop_thread); 1558 1559 kfree(threads); 1560 threads = NULL; 1561 } 1562 1563 torture_cleanup_end(); 1564 } 1565 1566 static struct kunit_suite kcsan_test_suite = { 1567 .name = "kcsan", 1568 .test_cases = kcsan_test_cases, 1569 .init = test_init, 1570 .exit = test_exit, 1571 }; 1572 static struct kunit_suite *kcsan_test_suites[] = { &kcsan_test_suite, NULL }; 1573 1574 __no_kcsan 1575 static void register_tracepoints(struct tracepoint *tp, void *ignore) 1576 { 1577 check_trace_callback_type_console(probe_console); 1578 if (!strcmp(tp->name, "console")) 1579 WARN_ON(tracepoint_probe_register(tp, probe_console, NULL)); 1580 } 1581 1582 __no_kcsan 1583 static void unregister_tracepoints(struct tracepoint *tp, void *ignore) 1584 { 1585 if (!strcmp(tp->name, "console")) 1586 tracepoint_probe_unregister(tp, probe_console, NULL); 1587 } 1588 1589 /* 1590 * We only want to do tracepoints setup and teardown once, therefore we have to 1591 * customize the init and exit functions and cannot rely on kunit_test_suite(). 1592 */ 1593 static int __init kcsan_test_init(void) 1594 { 1595 /* 1596 * Because we want to be able to build the test as a module, we need to 1597 * iterate through all known tracepoints, since the static registration 1598 * won't work here. 1599 */ 1600 for_each_kernel_tracepoint(register_tracepoints, NULL); 1601 return __kunit_test_suites_init(kcsan_test_suites); 1602 } 1603 1604 static void kcsan_test_exit(void) 1605 { 1606 __kunit_test_suites_exit(kcsan_test_suites); 1607 for_each_kernel_tracepoint(unregister_tracepoints, NULL); 1608 tracepoint_synchronize_unregister(); 1609 } 1610 1611 late_initcall_sync(kcsan_test_init); 1612 module_exit(kcsan_test_exit); 1613 1614 MODULE_LICENSE("GPL v2"); 1615 MODULE_AUTHOR("Marco Elver <[email protected]>"); 1616