Line data    Source code

       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     1345018 : static __always_inline void instrument_write(const volatile void *v, size_t size)
      40             : {
      41     1345018 :         kasan_check_write(v, size);
      42     1345025 :         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      120852 : static __always_inline void instrument_read_write(const volatile void *v, size_t size)
      55             : {
      56      120852 :         kasan_check_write(v, size);
      57      112305 :         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   274321976 : static __always_inline void instrument_atomic_read(const volatile void *v, size_t size)
      70             : {
      71   274262277 :         kasan_check_read(v, size);
      72   273141496 :         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     6789508 : static __always_inline void instrument_atomic_write(const volatile void *v, size_t size)
      85             : {
      86     6397777 :         kasan_check_write(v, size);
      87     6008175 :         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    27866747 : static __always_inline void instrument_atomic_read_write(const volatile void *v, size_t size)
     100             : {
     101    17340986 :         kasan_check_write(v, size);
     102    17288115 :         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      103698 : instrument_copy_to_user(void __user *to, const void *from, unsigned long n)
     117             : {
     118      103698 :         kasan_check_read(from, n);
     119      103703 :         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      201028 : instrument_copy_from_user(const void *to, const void __user *from, unsigned long n)
     134             : {
     135      201028 :         kasan_check_write(to, n);
     136      201027 :         kcsan_check_write(to, n);
     137             : }
     138             : 
     139             : #endif /* _LINUX_INSTRUMENTED_H */