1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 /* 4 * This header provides generic wrappers for memory access instrumentation that 5 * the compiler cannot emit for: KASAN, KCSAN. 6 */ 7 #ifndef _LINUX_INSTRUMENTED_H 8 #define _LINUX_INSTRUMENTED_H 9 10 #include <linux/compiler.h> 11 #include <linux/kasan-checks.h> 12 #include <linux/kcsan-checks.h> 13 #include <linux/types.h> 14 15 /** 16 * instrument_read - instrument regular read access 17 * 18 * Instrument a regular read access. The instrumentation should be inserted 19 * before the actual read happens. 20 * 21 * @ptr address of access 22 * @size size of access 23 */ 24 static __always_inline void instrument_read(const volatile void *v, size_t size) 25 { 26 kasan_check_read(v, size); 27 kcsan_check_read(v, size); 28 } 29 30 /** 31 * instrument_write - instrument regular write access 32 * 33 * Instrument a regular write access. The instrumentation should be inserted 34 * before the actual write happens. 35 * 36 * @ptr address of access 37 * @size size of access 38 */ 39 static __always_inline void instrument_write(const volatile void *v, size_t size) 40 { 41 kasan_check_write(v, size); 42 kcsan_check_write(v, size); 43 } 44 45 /** 46 * instrument_read_write - instrument regular read-write access 47 * 48 * Instrument a regular write access. The instrumentation should be inserted 49 * before the actual write happens. 50 * 51 * @ptr address of access 52 * @size size of access 53 */ 54 static __always_inline void instrument_read_write(const volatile void *v, size_t size) 55 { 56 kasan_check_write(v, size); 57 kcsan_check_read_write(v, size); 58 } 59 60 /** 61 * instrument_atomic_read - instrument atomic read access 62 * 63 * Instrument an atomic read access. The instrumentation should be inserted 64 * before the actual read happens. 65 * 66 * @ptr address of access 67 * @size size of access 68 */ 69 static __always_inline void instrument_atomic_read(const volatile void *v, size_t size) 70 { 71 kasan_check_read(v, size); 72 kcsan_check_atomic_read(v, size); 73 } 74 75 /** 76 * instrument_atomic_write - instrument atomic write access 77 * 78 * Instrument an atomic write access. The instrumentation should be inserted 79 * before the actual write happens. 80 * 81 * @ptr address of access 82 * @size size of access 83 */ 84 static __always_inline void instrument_atomic_write(const volatile void *v, size_t size) 85 { 86 kasan_check_write(v, size); 87 kcsan_check_atomic_write(v, size); 88 } 89 90 /** 91 * instrument_atomic_read_write - instrument atomic read-write access 92 * 93 * Instrument an atomic read-write access. The instrumentation should be 94 * inserted before the actual write happens. 95 * 96 * @ptr address of access 97 * @size size of access 98 */ 99 static __always_inline void instrument_atomic_read_write(const volatile void *v, size_t size) 100 { 101 kasan_check_write(v, size); 102 kcsan_check_atomic_read_write(v, size); 103 } 104 105 /** 106 * instrument_copy_to_user - instrument reads of copy_to_user 107 * 108 * Instrument reads from kernel memory, that are due to copy_to_user (and 109 * variants). The instrumentation must be inserted before the accesses. 110 * 111 * @to destination address 112 * @from source address 113 * @n number of bytes to copy 114 */ 115 static __always_inline void 116 instrument_copy_to_user(void __user *to, const void *from, unsigned long n) 117 { 118 kasan_check_read(from, n); 119 kcsan_check_read(from, n); 120 } 121 122 /** 123 * instrument_copy_from_user - instrument writes of copy_from_user 124 * 125 * Instrument writes to kernel memory, that are due to copy_from_user (and 126 * variants). The instrumentation should be inserted before the accesses. 127 * 128 * @to destination address 129 * @from source address 130 * @n number of bytes to copy 131 */ 132 static __always_inline void 133 instrument_copy_from_user(const void *to, const void __user *from, unsigned long n) 134 { 135 kasan_check_write(to, n); 136 kcsan_check_write(to, n); 137 } 138 139 #endif /* _LINUX_INSTRUMENTED_H */ 140