include/linux/instrumented.h

   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_atomic_read - instrument atomic read access
  47  *
  48  * Instrument an atomic read access. The instrumentation should be inserted
  49  * before the actual read happens.
  50  *
  51  * @ptr address of access
  52  * @size size of access
  53  */
  54 static __always_inline void instrument_atomic_read(const volatile void *v, size_t size)
  55 {
  56         kasan_check_read(v, size);
  57         kcsan_check_atomic_read(v, size);
  58 }
  59
  60 /**
  61  * instrument_atomic_write - instrument atomic write access
  62  *
  63  * Instrument an atomic write access. The instrumentation should be inserted
  64  * before the actual write happens.
  65  *
  66  * @ptr address of access
  67  * @size size of access
  68  */
  69 static __always_inline void instrument_atomic_write(const volatile void *v, size_t size)
  70 {
  71         kasan_check_write(v, size);
  72         kcsan_check_atomic_write(v, size);
  73 }
  74
  75 /**
  76  * instrument_copy_to_user - instrument reads of copy_to_user
  77  *
  78  * Instrument reads from kernel memory, that are due to copy_to_user (and
  79  * variants). The instrumentation must be inserted before the accesses.
  80  *
  81  * @to destination address
  82  * @from source address
  83  * @n number of bytes to copy
  84  */
  85 static __always_inline void
  86 instrument_copy_to_user(void __user *to, const void *from, unsigned long n)
  87 {
  88         kasan_check_read(from, n);
  89         kcsan_check_read(from, n);
  90 }
  91
  92 /**
  93  * instrument_copy_from_user - instrument writes of copy_from_user
  94  *
  95  * Instrument writes to kernel memory, that are due to copy_from_user (and
  96  * variants). The instrumentation should be inserted before the accesses.
  97  *
  98  * @to destination address
  99  * @from source address
 100  * @n number of bytes to copy
 101  */
 102 static __always_inline void
 103 instrument_copy_from_user(const void *to, const void __user *from, unsigned long n)
 104 {
 105         kasan_check_write(to, n);
 106         kcsan_check_write(to, n);
 107 }
 108
 109 #endif /* _LINUX_INSTRUMENTED_H */