kcsan: Support distinguishing volatile accesses

}

EXPORT_SYMBOL(__tsan_write_range);

/*

 * Use of explicit volatile is generally disallowed [1], however, volatile is

 * still used in various concurrent context, whether in low-level

 * synchronization primitives or for legacy reasons.

 * [1] https://lwn.net/Articles/233479/

 *

 * We only consider volatile accesses atomic if they are aligned and would pass

 * the size-check of compiletime_assert_rwonce_type().

 */

#define DEFINE_TSAN_VOLATILE_READ_WRITE(size)                                  \

	void __tsan_volatile_read##size(void *ptr)                             \

	{                                                                      \

		const bool is_atomic = size <= sizeof(long long) &&            \

				       IS_ALIGNED((unsigned long)ptr, size);   \

		if (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS) && is_atomic)      \

			return;                                                \

		check_access(ptr, size, is_atomic ? KCSAN_ACCESS_ATOMIC : 0);  \

	}                                                                      \

	EXPORT_SYMBOL(__tsan_volatile_read##size);                             \

	void __tsan_unaligned_volatile_read##size(void *ptr)                   \

		__alias(__tsan_volatile_read##size);                           \

	EXPORT_SYMBOL(__tsan_unaligned_volatile_read##size);                   \

	void __tsan_volatile_write##size(void *ptr)                            \

	{                                                                      \

		const bool is_atomic = size <= sizeof(long long) &&            \

				       IS_ALIGNED((unsigned long)ptr, size);   \

		if (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS) && is_atomic)      \

			return;                                                \

		check_access(ptr, size,                                        \

			     KCSAN_ACCESS_WRITE |                              \

				     (is_atomic ? KCSAN_ACCESS_ATOMIC : 0));   \

	}                                                                      \

	EXPORT_SYMBOL(__tsan_volatile_write##size);                            \

	void __tsan_unaligned_volatile_write##size(void *ptr)                  \

		__alias(__tsan_volatile_write##size);                          \

	EXPORT_SYMBOL(__tsan_unaligned_volatile_write##size)

DEFINE_TSAN_VOLATILE_READ_WRITE(1);

DEFINE_TSAN_VOLATILE_READ_WRITE(2);

DEFINE_TSAN_VOLATILE_READ_WRITE(4);

DEFINE_TSAN_VOLATILE_READ_WRITE(8);

DEFINE_TSAN_VOLATILE_READ_WRITE(16);

/*

 * The below are not required by KCSAN, but can still be emitted by the

 * compiler.

cc-param = --param -$(1)

endif

# Keep most options here optional, to allow enabling more compilers if absence

# of some options does not break KCSAN nor causes false positive reports.

CFLAGS_KCSAN := -fsanitize=thread \

	$(call cc-option,$(call cc-param,tsan-instrument-func-entry-exit=0) -fno-optimize-sibling-calls)

	$(call cc-option,$(call cc-param,tsan-instrument-func-entry-exit=0) -fno-optimize-sibling-calls) \

	$(call cc-param,tsan-distinguish-volatile=1)

endif # CONFIG_KCSAN