// SPDX-License-Identifier: GPL-2.0 /* * KCSAN test with various race scenarious to test runtime behaviour . Since the * interface with which KCSAN ' s reports are obtained is via the console , this is * the output we should verify . For each test case checks the presence ( or * absence ) of generated reports . Relies on ' console ' tracepoint to capture * reports as they appear in the kernel log . * * Makes use of KUnit for test organization , and the Torture framework for test * thread control . * * Copyright ( C ) 2020 , Google LLC . * Author : Marco Elver < elver @ google . com > #define pr_fmt(fmt) "kcsan_test: " fmt#include <kunit/test.h>#include <linux/atomic.h>#include <linux/bitops.h>#include <linux/jiffies.h>#include <linux/kcsan-checks.h>#include <linux/kernel.h>#include <linux/mutex.h>#include <linux/sched.h>#include <linux/seqlock.h>#include <linux/spinlock.h>#include <linux/string.h>#include <linux/timer.h>#include <linux/torture.h>#include <linux/tracepoint.h>#include <linux/types.h>#include <trace/events/printk.h>#define KCSAN_TEST_REQUIRES(test, cond) do { \if (!(cond)) \"Test requires: " #cond ); \while (0 )#ifdef CONFIG_CC_HAS_TSAN_COMPOUND_READ_BEFORE_WRITE#define __KCSAN_ACCESS_RW(alt) (KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE)#else #define __KCSAN_ACCESS_RW(alt) (alt)#endif /* Points to current test-case memory access "kernels". */ static void (*access_kernels[2 ])(void );static struct task_struct **threads; /* Lists of threads. */ static unsigned long end_time; /* End time of test. */ /* Report as observed from console. */ static struct {int nlines;char lines[3 ][512 ];/* Setup test checking loop. */ static __no_kcsan inline void void (*func1)(void ), void (*func2)(void ))/* * Require at least as long as KCSAN_REPORT_ONCE_IN_MS , to ensure at * least one race is reported . 500 );/* Signal start; release potential initialization of shared data. */ 0 ], func1);1 ], func2);/* End test checking loop. */ static __no_kcsan inline bool bool stop)if (!stop && time_before(jiffies, end_time)) {/* Continue checking */ return false ;return true ;/* * Probe for console output : checks if a race was reported , and obtains observed * lines of interest . static void probe_console(void *ignore, const char *buf, size_t len)unsigned long flags;int nlines;/* * Note that KCSAN reports under a global lock , so we do not risk the * possibility of having multiple reports interleaved . If that were the * case , we ' d expect tests to fail . if (strnstr(buf, "BUG: KCSAN: " , len) && strnstr(buf, "test_" , len)) {/* * KCSAN report and related to the test . * * The provided @ buf is not NUL - terminated ; copy no more than * @ len bytes and let strscpy ( ) add the missing NUL - terminator . 0 ], buf, min(len + 1 , sizeof (observed.lines[0 ])));1 ;else if ((nlines == 1 || nlines == 2 ) && strnstr(buf, "bytes by" , len)) {1 , sizeof (observed.lines[0 ])));if (strnstr(buf, "race at unknown origin" , len)) {if (WARN_ON(nlines != 2 ))goto out;/* No second line of interest. */ "<none>" );/* Publish new nlines. */ /* Check if a report related to the test exists. */ static bool report_available(void )return READ_ONCE(observed.nlines) == ARRAY_SIZE(observed.lines);/* Report information we expect in a report. */ struct expect_report {/* Access information of both accesses. */ struct {void *fn; /* Function pointer to expected function of top frame. */ void *addr; /* Address of access; unchecked if NULL. */ /* Size of access; unchecked if @addr is NULL. */ int type; /* Access type, see KCSAN_ACCESS definitions. */ 2 ];/* Check observed report matches information in @r. */ static bool __report_matches(const struct expect_report *r)const bool is_assert = (r->access[0 ].type | r->access[1 ].type) & KCSAN_ACCESS_ASSERT;bool ret = false ;unsigned long flags;const char *end;char *cur;int i;/* Doubled-checked locking. */ if (!report_available())return false ;sizeof (observed.lines), GFP_KERNEL);if (WARN_ON(!expect))return false ;/* Generate expected report contents. */ /* Title */ 0 ];0 ][sizeof (expect[0 ]) - 1 ];"BUG: KCSAN: %s in " ,"assert: race" : "data-race" );if (r->access[1 ].fn) {char tmp[2 ][64 ];int cmp;/* Expect lexographically sorted function names in title. */ 0 ], sizeof (tmp[0 ]), "%pS" , r->access[0 ].fn);1 ], sizeof (tmp[1 ]), "%pS" , r->access[1 ].fn);0 ], tmp[1 ]);"%ps / %ps" ,0 ? r->access[0 ].fn : r->access[1 ].fn,0 ? r->access[1 ].fn : r->access[0 ].fn);else {"%pS" , r->access[0 ].fn);/* The exact offset won't match, remove it. */ 0 ], '+' );if (cur)'\0' ;/* Access 1 */ 1 ];1 ][sizeof (expect[1 ]) - 1 ];if (!r->access[1 ].fn)"race at unknown origin, with " );/* Access 1 & 2 */ for (i = 0 ; i < 2 ; ++i) {const int ty = r->access[i].type;const char *const access_type ="assert no accesses" :"assert no writes" ) :"read-write" :"write" ) :"read" );const bool is_atomic = (ty & KCSAN_ACCESS_ATOMIC);const bool is_scoped = (ty & KCSAN_ACCESS_SCOPED);const char *const access_type_aux =" (marked, reordered)" " (marked)" " (reordered)" : "" ));if (i == 1 ) {/* Access 2 */ 2 ];2 ][sizeof (expect[2 ]) - 1 ];if (!r->access[1 ].fn) {/* Dummy string if no second access is available. */ "<none>" );break ;"%s%s to " , access_type,if (r->access[i].addr) /* Address is optional. */ "0x%px of %zu bytes" ,if (!report_available())goto out; /* A new report is being captured. */ /* Finally match expected output to what we actually observed. */ 0 ], expect[0 ]) &&/* Access info may appear in any order. */ 1 ], expect[1 ]) &&2 ], expect[2 ])) ||1 ], expect[2 ]) &&2 ], expect[1 ])));return ret;static __always_inline const struct expect_report *struct expect_report *r, int accesses)3 );if (accesses & 1 )0 ].type |= KCSAN_ACCESS_SCOPED;else 0 ].type &= ~KCSAN_ACCESS_SCOPED;if (accesses & 2 )1 ].type |= KCSAN_ACCESS_SCOPED;else 1 ].type &= ~KCSAN_ACCESS_SCOPED;return r;static bool report_matches_any_reordered(struct expect_report *r)return __report_matches(__report_set_scoped(r, 0 )) ||1 )) ||2 )) ||3 ));#ifdef CONFIG_KCSAN_WEAK_MEMORY/* Due to reordering accesses, any access may appear as "(reordered)". */ #define report_matches report_matches_any_reordered#else #define report_matches __report_matches#endif /* ===== Test kernels ===== */ static long test_sink;static long test_var;/* @test_array should be large enough to fall into multiple watchpoint slots. */ static long test_array[3 * PAGE_SIZE / sizeof (long )];static struct {long val[8 ];static long __data_racy test_data_racy;static DEFINE_SEQLOCK(test_seqlock);static DEFINE_SPINLOCK(test_spinlock);static DEFINE_MUTEX(test_mutex);/* * Helper to avoid compiler optimizing out reads , and to generate source values * for writes . static noinline void sink_value(long v) { WRITE_ONCE(test_sink, v); }/* * Generates a delay and some accesses that enter the runtime but do not produce * data races . static noinline void test_delay(int iter)while (iter--)static noinline void test_kernel_read(void ) { sink_value(test_var); }static noinline void test_kernel_write(void )1 ;static noinline void test_kernel_write_nochange(void ) { test_var = 42 ; }/* Suffixed by value-change exception filter. */ static noinline void test_kernel_write_nochange_rcu(void ) { test_var = 42 ; }static noinline void test_kernel_read_atomic(void )static noinline void test_kernel_write_atomic(void )1 );static noinline void test_kernel_atomic_rmw(void )/* Use builtin, so we can set up the "bad" atomic/non-atomic scenario. */ 1 , __ATOMIC_RELAXED);static noinline void test_kernel_write_uninstrumented(void ) { test_var++; }static noinline void test_kernel_data_race(void ) { data_race(test_var++); }static noinline void test_kernel_data_racy_qualifier(void ) { test_data_racy++; }static noinline void test_kernel_assert_writer(void )static noinline void test_kernel_assert_access(void )#define TEST_CHANGE_BITS 0 xff00ff00static noinline void test_kernel_change_bits(void )if (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {/* * Avoid race of unknown origin for this test , just pretend they * are atomic . else static noinline void test_kernel_assert_bits_change(void )static noinline void test_kernel_assert_bits_nochange(void )/* * Scoped assertions do trigger anywhere in scope . However , the report should * still only point at the start of the scope . static noinline void test_enter_scope(void )int x = 0 ;/* Unrelated accesses to scoped assert. */ sizeof (x));static noinline void test_kernel_assert_writer_scoped(void )static noinline void test_kernel_assert_access_scoped(void )static noinline void test_kernel_rmw_array(void )int i;for (i = 0 ; i < ARRAY_SIZE(test_array); ++i)static noinline void test_kernel_write_struct(void )sizeof (test_struct));3 ]++; /* induce value change */ static noinline void test_kernel_write_struct_part(void )3 ] = 42 ;static noinline void test_kernel_read_struct_zero_size(void )3 ], 0 );static noinline void test_kernel_jiffies_reader(void )long )jiffies);static noinline void test_kernel_seqlock_reader(void )unsigned int seq;do {while (read_seqretry(&test_seqlock, seq));static noinline void test_kernel_seqlock_writer(void )unsigned long flags;static noinline void test_kernel_atomic_builtins(void )/* * Generate concurrent accesses , expecting no reports , ensuring KCSAN * treats builtin atomics as actually atomic . static noinline void test_kernel_xor_1bit(void )/* Do not report data races between the read-writes. */ 0 x10000;#define TEST_KERNEL_LOCKED(name, acquire, release) \static noinline void test_kernel_## name(void ) \long *flag = &test_struct.val[0 ]; \long v = 0 ; \if (!(acquire)) \return ; \while (v++ < 100 ) { \10 ); \0 , 1 ) == 0 ,0 ));0 , 1 ) == 0 ,0 ));1 , 0 , __ATOMIC_ACQUIRE, __ATOMIC_RELAXED),0 , __ATOMIC_RELEASE));1 , 0 , __ATOMIC_RELAXED, __ATOMIC_RELAXED),0 , __ATOMIC_RELAXED));/* ===== Test cases ===== */ /* * Tests that various barriers have the expected effect on internal state . Not * exhaustive on atomic_t operations . Unlike the selftest , also checks for * too - strict barrier instrumentation ; these can be tolerated , because it does * not cause false positives , but at least we should be aware of such cases . static void test_barrier_nothreads(struct kunit *test)#ifdef CONFIG_KCSAN_WEAK_MEMORYstruct kcsan_scoped_access *reorder_access = ¤t->kcsan_ctx.reorder_access;#else struct kcsan_scoped_access *reorder_access = NULL;#endif 0 );#define __KCSAN_EXPECT_BARRIER(access_type, barrier, order_before, name) \do { \sizeof (test_var); \0 : sizeof (test_var), \"improperly instrumented type=(" #access_type "): " name); \while (0 )#define KCSAN_EXPECT_READ_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(0 , b, o, #b )#define KCSAN_EXPECT_WRITE_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(KCSAN_ACCESS_WRITE, b, o, #b )#define KCSAN_EXPECT_RW_BARRIER(b, o) __KCSAN_EXPECT_BARRIER(KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE, b, o, #b )/* * Lockdep initialization can strengthen certain locking operations due * to calling into instrumented files ; " warm up " our locks . /* Force creating a valid entry in reorder_access first. */ 0 ;while (test_var++ < 1000000 && reorder_access->size != sizeof (test_var))sizeof (test_var));sizeof (test_var));/* No watchpoints in called functions. */ true );false );true );true );false );true );false );true );true );true );true );0 ), true );false );0 ), true );0 ), true );0 ), true );0 ), false );0 , 0 ), true );0 , 0 ), true );0 , 0 ), false );false );false );0 ), false );0 ), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );false );true );false );true );false );true );true );true );false );true );true );false );true );false );true );true );true );0 ), true );false );0 ), true );0 ), true );0 ), true );0 ), false );0 , 0 ), true );0 , 0 ), true );0 , 0 ), false );false );false );0 ), false );0 ), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );false );true );false );true );false );true );true );true );true );true );true );true );true );true );true );true );true );0 ), true );false );0 ), true );0 ), true );0 ), true );0 ), false );0 , 0 ), true );0 , 0 ), true );0 , 0 ), false );false );false );0 ), false );0 ), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );1 , &dummy), true );1 , &dummy), false );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );0 , &test_var), true );false );true );false );true );false );true );1 , &test_var), true );1 , &test_var), true );1 , &test_var), true );/* Simple test with normal data race. */ static void test_basic(struct kunit *test)struct expect_report expect = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), 0 },struct expect_report never = {sizeof (test_var), 0 },sizeof (test_var), 0 },bool match_expect = false ;bool match_never = false ;do {while (!end_test_checks(match_never));/* * Stress KCSAN with lots of concurrent races on different addresses until * timeout . static void test_concurrent_races(struct kunit *test)struct expect_report expect = {/* NULL will match any address. */ 0 , __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },0 , __KCSAN_ACCESS_RW(0 ) },struct expect_report never = {0 , 0 },0 , 0 },bool match_expect = false ;bool match_never = false ;do {while (!end_test_checks(false ));/* Sanity check matches exist. */ /* Test the KCSAN_REPORT_VALUE_CHANGE_ONLY option. */ static void test_novalue_change(struct kunit *test)struct expect_report expect_rw = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), 0 },struct expect_report expect_ww = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), KCSAN_ACCESS_WRITE },bool match_expect = false ;/* Reset value. */ do {while (!end_test_checks(match_expect));if (IS_ENABLED(CONFIG_KCSAN_REPORT_VALUE_CHANGE_ONLY))else /* * Test that the rules where the KCSAN_REPORT_VALUE_CHANGE_ONLY option should * never apply work . static void test_novalue_change_exception(struct kunit *test)struct expect_report expect_rw = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), 0 },struct expect_report expect_ww = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), KCSAN_ACCESS_WRITE },bool match_expect = false ;/* Reset value. */ do {while (!end_test_checks(match_expect));/* Test that data races of unknown origin are reported. */ static void test_unknown_origin(struct kunit *test)struct expect_report expect = {sizeof (test_var), 0 },bool match_expect = false ;do {while (!end_test_checks(match_expect));if (IS_ENABLED(CONFIG_KCSAN_REPORT_RACE_UNKNOWN_ORIGIN))else /* Test KCSAN_ASSUME_PLAIN_WRITES_ATOMIC if it is selected. */ static void test_write_write_assume_atomic(struct kunit *test)struct expect_report expect = {sizeof (test_var), KCSAN_ACCESS_WRITE },sizeof (test_var), KCSAN_ACCESS_WRITE },bool match_expect = false ;do {/* induce value-change */ while (!end_test_checks(match_expect));if (IS_ENABLED(CONFIG_KCSAN_ASSUME_PLAIN_WRITES_ATOMIC))else /* * Test that data races with writes larger than word - size are always reported , * even if KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected . static void test_write_write_struct(struct kunit *test)struct expect_report expect = {sizeof (test_struct), KCSAN_ACCESS_WRITE },sizeof (test_struct), KCSAN_ACCESS_WRITE },bool match_expect = false ;do {while (!end_test_checks(match_expect));/* * Test that data races where only one write is larger than word - size are always * reported , even if KCSAN_ASSUME_PLAIN_WRITES_ATOMIC is selected . static void test_write_write_struct_part(struct kunit *test)struct expect_report expect = {sizeof (test_struct), KCSAN_ACCESS_WRITE },3 ], sizeof (test_struct.val[3 ]), KCSAN_ACCESS_WRITE },bool match_expect = false ;do {while (!end_test_checks(match_expect));/* Test that races with atomic accesses never result in reports. */ static void test_read_atomic_write_atomic(struct kunit *test)bool match_never = false ;do {while (!end_test_checks(match_never));/* Test that a race with an atomic and plain access result in reports. */ static void test_read_plain_atomic_write(struct kunit *test)struct expect_report expect = {sizeof (test_var), 0 },sizeof (test_var), KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC },bool match_expect = false ;do {while (!end_test_checks(match_expect));/* Test that atomic RMWs generate correct report. */ static void test_read_plain_atomic_rmw(struct kunit *test)struct expect_report expect = {sizeof (test_var), 0 },sizeof (test_var),bool match_expect = false ;do {while (!end_test_checks(match_expect));/* Zero-sized accesses should never cause data race reports. */ static void test_zero_size_access(struct kunit *test)struct expect_report expect = {sizeof (test_struct), KCSAN_ACCESS_WRITE },sizeof (test_struct), KCSAN_ACCESS_WRITE },struct expect_report never = {sizeof (test_struct), KCSAN_ACCESS_WRITE },3 ], 0 , 0 },bool match_expect = false ;bool match_never = false ;do {while (!end_test_checks(match_never));/* Sanity check. */ /* Test the data_race() macro. */ static void test_data_race(struct kunit *test)bool match_never = false ;do {while (!end_test_checks(match_never));/* Test the __data_racy type qualifier. */ static void test_data_racy_qualifier(struct kunit *test)bool match_never = false ;r);do {while (!end_test_checks(match_never));static void test_assert_exclusive_writer(struct kunit *test)struct expect_report expect = {sizeof (test_var), KCSAN_ACCESS_ASSERT },sizeof (test_var), KCSAN_ACCESS_WRITE },bool match_expect = false ;do {while (!end_test_checks(match_expect));static void test_assert_exclusive_access(struct kunit *test)struct expect_report expect = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE },sizeof (test_var), 0 },bool match_expect = false ;do {while (!end_test_checks(match_expect));static void test_assert_exclusive_access_writer(struct kunit *test)struct expect_report expect_access_writer = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE },sizeof (test_var), KCSAN_ACCESS_ASSERT },struct expect_report expect_access_access = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE },sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE },struct expect_report never = {sizeof (test_var), KCSAN_ACCESS_ASSERT },sizeof (test_var), KCSAN_ACCESS_ASSERT },bool match_expect_access_writer = false ;bool match_expect_access_access = false ;bool match_never = false ;do {while (!end_test_checks(match_never));static void test_assert_exclusive_bits_change(struct kunit *test)struct expect_report expect = {sizeof (test_var), KCSAN_ACCESS_ASSERT },sizeof (test_var),0 : KCSAN_ACCESS_ATOMIC) },bool match_expect = false ;do {while (!end_test_checks(match_expect));static void test_assert_exclusive_bits_nochange(struct kunit *test)bool match_never = false ;do {while (!end_test_checks(match_never));static void test_assert_exclusive_writer_scoped(struct kunit *test)struct expect_report expect_start = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_SCOPED },sizeof (test_var), KCSAN_ACCESS_WRITE },struct expect_report expect_inscope = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_SCOPED },sizeof (test_var), KCSAN_ACCESS_WRITE },bool match_expect_start = false ;bool match_expect_inscope = false ;do {while (!end_test_checks(match_expect_inscope));static void test_assert_exclusive_access_scoped(struct kunit *test)struct expect_report expect_start1 = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_SCOPED },sizeof (test_var), 0 },struct expect_report expect_start2 = {0 ], expect_start1.access[0 ] },struct expect_report expect_inscope = {sizeof (test_var), KCSAN_ACCESS_ASSERT | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_SCOPED },sizeof (test_var), 0 },bool match_expect_start = false ;bool match_expect_inscope = false ;1000 ); /* This test requires a bit more time. */ do {while (!end_test_checks(match_expect_inscope));/* * jiffies is special ( declared to be volatile ) and its accesses are typically * not marked ; this test ensures that the compiler nor KCSAN gets confused about * jiffies ' s declaration on different architectures . static void test_jiffies_noreport(struct kunit *test)bool match_never = false ;do {while (!end_test_checks(match_never));/* Test that racing accesses in seqlock critical sections are not reported. */ static void test_seqlock_noreport(struct kunit *test)bool match_never = false ;do {while (!end_test_checks(match_never));/* * Test atomic builtins work and required instrumentation functions exist . We * also test that KCSAN understands they ' re atomic by racing with them via * test_kernel_atomic_builtins ( ) , and expect no reports . * * The atomic builtins _ SHOULD NOT_ be used in normal kernel code ! static void test_atomic_builtins(struct kunit *test)bool match_never = false ;do {long tmp;42 L, __ATOMIC_RELAXED);42 L, __atomic_load_n(&test_var, __ATOMIC_RELAXED));42 L, __atomic_exchange_n(&test_var, 20 , __ATOMIC_RELAXED));20 L, test_var);20 L;30 L,0 , __ATOMIC_RELAXED,20 L);30 L);40 L,1 , __ATOMIC_RELAXED,30 L);30 L);30 L, __atomic_fetch_add(&test_var, 1 , __ATOMIC_RELAXED));31 L, __atomic_fetch_sub(&test_var, 1 , __ATOMIC_RELAXED));30 L, __atomic_fetch_and(&test_var, 0 xf, __ATOMIC_RELAXED));14 L, __atomic_fetch_xor(&test_var, 0 xf, __ATOMIC_RELAXED));1 L, __atomic_fetch_or(&test_var, 0 xf0, __ATOMIC_RELAXED));241 L, __atomic_fetch_nand(&test_var, 0 xf, __ATOMIC_RELAXED));2 L, test_var);while (!end_test_checks(match_never));static void test_1bit_value_change(struct kunit *test)struct expect_report expect = {sizeof (test_var), 0 },sizeof (test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },bool match = false ;do {while (!end_test_checks(match));if (IS_ENABLED(CONFIG_KCSAN_PERMISSIVE))else static void test_correct_barrier(struct kunit *test)struct expect_report expect = {sizeof (test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },sizeof (test_var), __KCSAN_ACCESS_RW(0 ) },bool match_expect = false ;0 ] = 0 ; /* init unlocked */ do {while (!end_test_checks(match_expect));static void test_missing_barrier(struct kunit *test)struct expect_report expect = {sizeof (test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },sizeof (test_var), __KCSAN_ACCESS_RW(0 ) },bool match_expect = false ;0 ] = 0 ; /* init unlocked */ do {while (!end_test_checks(match_expect));if (IS_ENABLED(CONFIG_KCSAN_WEAK_MEMORY))else static void test_atomic_builtins_correct_barrier(struct kunit *test)struct expect_report expect = {sizeof (test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },sizeof (test_var), __KCSAN_ACCESS_RW(0 ) },bool match_expect = false ;0 ] = 0 ; /* init unlocked */ do {while (!end_test_checks(match_expect));static void test_atomic_builtins_missing_barrier(struct kunit *test)struct expect_report expect = {sizeof (test_var), __KCSAN_ACCESS_RW(KCSAN_ACCESS_WRITE) },sizeof (test_var), __KCSAN_ACCESS_RW(0 ) },bool match_expect = false ;0 ] = 0 ; /* init unlocked */ do {while (!end_test_checks(match_expect));if (IS_ENABLED(CONFIG_KCSAN_WEAK_MEMORY))else /* * Generate thread counts for all test cases . Values generated are in interval * [ 2 , 5 ] followed by exponentially increasing thread counts from 8 to 32 . * * The thread counts are chosen to cover potentially interesting boundaries and * corner cases ( 2 to 5 ) , and then stress the system with larger counts . static const void *nthreads_gen_params(const void *prev, char *desc)long nthreads = (long )prev;if (nthreads < 0 || nthreads >= 32 )0 ; /* stop */ else if (!nthreads)2 ; /* initial value */ else if (nthreads < 5 )else if (nthreads == 5 )8 ;else 2 ;if (!preempt_model_preemptible() ||/* * Without any preemption , keep 2 CPUs free for other tasks , one * of which is the main test case function checking for * completion or failure . const long min_unused_cpus = preempt_model_none() ? 2 : 0 ;const long min_required_cpus = 2 + min_unused_cpus;if (num_online_cpus() < min_required_cpus) {"Too few online CPUs (%u < %ld) for test\n" ,0 ;else if (nthreads >= num_online_cpus() - min_unused_cpus) {/* Use negative value to indicate last param. */ "Limiting number of threads to %ld (only %d online CPUs)\n" ,"threads=%ld" , abs(nthreads));return (void *)nthreads;#define KCSAN_KUNIT_CASE(test_name) KUNIT_CASE_PARAM(test_name, nthreads_gen_params)static struct kunit_case kcsan_test_cases[] = {/* ===== End test cases ===== */ /* Concurrent accesses from interrupts. */ static void access_thread_timer(struct timer_list *timer)static atomic_t cnt = ATOMIC_INIT(0 );unsigned int idx;void (*func)(void );unsigned int )atomic_inc_return(&cnt) % ARRAY_SIZE(access_kernels);/* Acquire potential initialization. */ if (func)/* The main loop for each thread. */ static int access_thread(void *arg)struct timer_list timer;unsigned int cnt = 0 ;unsigned int idx;void (*func)(void );0 );do {if (!timer_pending(&timer))1 );else {/* Iterate through all kernels. */ /* Acquire potential initialization. */ if (func)while (!torture_must_stop());"access_thread" );return 0 ;static int test_init(struct kunit *test)unsigned long flags;int nthreads;int i;for (i = 0 ; i < ARRAY_SIZE(observed.lines); ++i)0 ] = '\0' ;0 ;if (strstr(test->name, "nothreads" ))return 0 ;if (!torture_init_begin((char *)test->name, 1 ))return -EBUSY;if (WARN_ON(threads))goto err;for (i = 0 ; i < ARRAY_SIZE(access_kernels); ++i) {if (WARN_ON(access_kernels[i]))goto err;long )test->param_value);if (WARN_ON(!nthreads))goto err;1 , sizeof (struct task_struct *), GFP_KERNEL);if (WARN_ON(!threads))goto err;for (i = 0 ; i < nthreads; ++i) {if (torture_create_kthread(access_thread, NULL, threads[i]))goto err;return 0 ;return -EINVAL;static void test_exit(struct kunit *test)struct task_struct **stop_thread;int i;if (strstr(test->name, "nothreads" ))return ;if (torture_cleanup_begin())return ;for (i = 0 ; i < ARRAY_SIZE(access_kernels); ++i)if (threads) {for (stop_thread = threads; *stop_thread; stop_thread++)static void register_tracepoints(void )static void unregister_tracepoints(void )static int kcsan_suite_init(struct kunit_suite *suite)return 0 ;static void kcsan_suite_exit(struct kunit_suite *suite)static struct kunit_suite kcsan_test_suite = {"kcsan" ,exit = test_exit,"KCSAN test suite" );"GPL v2" );"Marco Elver <elver@google.com>" );
Messung V0.5 in Prozent C=95 H=80 G=87
¤ Dauer der Verarbeitung: 0.27 Sekunden
(vorverarbeitet am 2026-09-29)
¤ *© Formatika GbR, Deutschland
