cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

instrumented.h (3685B)

      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 */
     24static __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 */
     39static __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 */
     54static __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 */
     69static __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 */
     84static __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 */
     99static __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 */
    115static __always_inline void
    116instrument_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 */
    132static __always_inline void
    133instrument_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 */