kcsan-checks.h File Reference

#include <linux/compiler_attributes.h>
#include <linux/types.h>

Include dependency graph for kcsan-checks.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	kcsan_scoped_access

Macros
#define	KCSAN_ACCESS_WRITE   (1 << 0) /* Access is a write. */
#define	KCSAN_ACCESS_COMPOUND   (1 << 1) /* Compounded read-write instrumentation. */
#define	KCSAN_ACCESS_ATOMIC   (1 << 2) /* Access is atomic. */
#define	KCSAN_ACCESS_ASSERT   (1 << 3) /* Access is an assertion. */
#define	KCSAN_ACCESS_SCOPED   (1 << 4) /* Access is a scoped access. */
#define	__kcsan_cleanup_scoped   __maybe_unused
#define	kcsan_mb()   do { } while (0)
#define	kcsan_wmb()   do { } while (0)
#define	kcsan_rmb()   do { } while (0)
#define	kcsan_release()   do { } while (0)
#define	__kcsan_check_read(ptr, size)   __kcsan_check_access(ptr, size, 0)
#define	__kcsan_check_write(ptr, size)    __kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_WRITE)
#define	__kcsan_check_read_write(ptr, size)    __kcsan_check_access(ptr, size, KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE)
#define	kcsan_check_read(ptr, size)   kcsan_check_access(ptr, size, 0)
#define	kcsan_check_write(ptr, size)    kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_WRITE)
#define	kcsan_check_read_write(ptr, size)    kcsan_check_access(ptr, size, KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE)
#define	kcsan_check_atomic_read(ptr, size)    kcsan_check_access(ptr, size, KCSAN_ACCESS_ATOMIC)
#define	kcsan_check_atomic_write(ptr, size)    kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_ATOMIC | KCSAN_ACCESS_WRITE)
#define	kcsan_check_atomic_read_write(ptr, size)    kcsan_check_access(ptr, size, KCSAN_ACCESS_ATOMIC | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_COMPOUND)
#define	ASSERT_EXCLUSIVE_WRITER(var)    __kcsan_check_access(&(var), sizeof(var), KCSAN_ACCESS_ASSERT)
#define	__kcsan_scoped_name(c, suffix)   __kcsan_scoped_##c##suffix
#define	__ASSERT_EXCLUSIVE_SCOPED(var, type, id)
#define	ASSERT_EXCLUSIVE_WRITER_SCOPED(var)    __ASSERT_EXCLUSIVE_SCOPED(var, KCSAN_ACCESS_ASSERT, __COUNTER__)
#define	ASSERT_EXCLUSIVE_ACCESS(var)    __kcsan_check_access(&(var), sizeof(var), KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ASSERT)
#define	ASSERT_EXCLUSIVE_ACCESS_SCOPED(var)    __ASSERT_EXCLUSIVE_SCOPED(var, KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ASSERT, __COUNTER__)
#define	ASSERT_EXCLUSIVE_BITS(var, mask)

Macro Definition Documentation

__ASSERT_EXCLUSIVE_SCOPED

#define __ASSERT_EXCLUSIVE_SCOPED	(		var,
			type,
			id
	)

Value:

    struct kcsan_scoped_access __kcsan_scoped_name(id, _)                  \
        __kcsan_cleanup_scoped;                                        \
    struct kcsan_scoped_access *__kcsan_scoped_name(id, _dummy_p)          \
        __maybe_unused = kcsan_begin_scoped_access(                    \
            &(var), sizeof(var), KCSAN_ACCESS_SCOPED | (type),     \
            &__kcsan_scoped_name(id, _))

__kcsan_check_read

#define __kcsan_check_read	(		ptr,
			size
	)		__kcsan_check_access(ptr, size, 0)

__kcsan_check_read - check regular read access for races

@ptr: address of access @size: size of access

__kcsan_check_read_write

#define __kcsan_check_read_write	(		ptr,
			size
	)		__kcsan_check_access(ptr, size, KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE)

__kcsan_check_read_write - check regular read-write access for races

@ptr: address of access @size: size of access

__kcsan_check_write

#define __kcsan_check_write	(		ptr,
			size
	)		__kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_WRITE)

__kcsan_check_write - check regular write access for races

@ptr: address of access @size: size of access

__kcsan_cleanup_scoped

#define __kcsan_cleanup_scoped   __maybe_unused

__kcsan_scoped_name

#define __kcsan_scoped_name	(		c,
			suffix
	)		__kcsan_scoped_##c##suffix

ASSERT_EXCLUSIVE_ACCESS

#define ASSERT_EXCLUSIVE_ACCESS

(

var

)

__kcsan_check_access(&(var), sizeof(var), KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ASSERT)

ASSERT_EXCLUSIVE_ACCESS_SCOPED

#define ASSERT_EXCLUSIVE_ACCESS_SCOPED

(

var

)

__ASSERT_EXCLUSIVE_SCOPED(var, KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ASSERT, __COUNTER__)

ASSERT_EXCLUSIVE_BITS

#define ASSERT_EXCLUSIVE_BITS	(		var,
			mask
	)

Value:

    do {                                                                   \
        kcsan_set_access_mask(mask);                                   \
        __kcsan_check_access(&(var), sizeof(var), KCSAN_ACCESS_ASSERT);\
        kcsan_set_access_mask(0);                                      \
        kcsan_atomic_next(1);                                          \
    } while (0)

ASSERT_EXCLUSIVE_WRITER

#define ASSERT_EXCLUSIVE_WRITER

(

var

)

__kcsan_check_access(&(var), sizeof(var), KCSAN_ACCESS_ASSERT)

ASSERT_EXCLUSIVE_WRITER_SCOPED

#define ASSERT_EXCLUSIVE_WRITER_SCOPED

(

var

)

__ASSERT_EXCLUSIVE_SCOPED(var, KCSAN_ACCESS_ASSERT, __COUNTER__)

KCSAN_ACCESS_ASSERT

#define KCSAN_ACCESS_ASSERT   (1 << 3) /* Access is an assertion. */

KCSAN_ACCESS_ATOMIC

#define KCSAN_ACCESS_ATOMIC   (1 << 2) /* Access is atomic. */

KCSAN_ACCESS_COMPOUND

#define KCSAN_ACCESS_COMPOUND   (1 << 1) /* Compounded read-write instrumentation. */

KCSAN_ACCESS_SCOPED

#define KCSAN_ACCESS_SCOPED   (1 << 4) /* Access is a scoped access. */

KCSAN_ACCESS_WRITE

#define KCSAN_ACCESS_WRITE   (1 << 0) /* Access is a write. */

kcsan_check_atomic_read

#define kcsan_check_atomic_read	(		ptr,
			size
	)		kcsan_check_access(ptr, size, KCSAN_ACCESS_ATOMIC)

kcsan_check_atomic_read_write

#define kcsan_check_atomic_read_write	(		ptr,
			size
	)		kcsan_check_access(ptr, size, KCSAN_ACCESS_ATOMIC | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_COMPOUND)

kcsan_check_atomic_write

#define kcsan_check_atomic_write	(		ptr,
			size
	)		kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_ATOMIC | KCSAN_ACCESS_WRITE)

kcsan_check_read

#define kcsan_check_read	(		ptr,
			size
	)		kcsan_check_access(ptr, size, 0)

kcsan_check_read - check regular read access for races

@ptr: address of access @size: size of access

kcsan_check_read_write

#define kcsan_check_read_write	(		ptr,
			size
	)		kcsan_check_access(ptr, size, KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE)

kcsan_check_read_write - check regular read-write access for races

@ptr: address of access @size: size of access

kcsan_check_write

#define kcsan_check_write	(		ptr,
			size
	)		kcsan_check_access(absolute_pointer(ptr), size, KCSAN_ACCESS_WRITE)

kcsan_check_write - check regular write access for races

@ptr: address of access @size: size of access

kcsan_mb

#define kcsan_mb

(

)

do { } while (0)

kcsan_release

#define kcsan_release

(

)

do { } while (0)

kcsan_rmb

#define kcsan_rmb

(

)

do { } while (0)

kcsan_wmb

#define kcsan_wmb

(

)

do { } while (0)