scripts/atomic/gen-atomic-instrumented.sh

   1 #!/bin/sh
   2 # SPDX-License-Identifier: GPL-2.0
   3
   4 ATOMICDIR=$(dirname $0)
   5
   6 . ${ATOMICDIR}/atomic-tbl.sh
   7
   8 #gen_param_check(meta, arg)
   9 gen_param_check()
  10 {
  11         local meta="$1"; shift
  12         local arg="$1"; shift
  13         local type="${arg%%:*}"
  14         local name="$(gen_param_name "${arg}")"
  15         local rw="write"
  16
  17         case "${type#c}" in
  18         i) return;;
  19         esac
  20
  21         if [ ${type#c} != ${type} ]; then
  22                 # We don't write to constant parameters.
  23                 rw="read"
  24         elif [ "${meta}" != "s" ]; then
  25                 # An atomic RMW: if this parameter is not a constant, and this atomic is
  26                 # not just a 's'tore, this parameter is both read from and written to.
  27                 rw="read_write"
  28         fi
  29
  30         printf "\tinstrument_atomic_${rw}(${name}, sizeof(*${name}));\n"
  31 }
  32
  33 #gen_params_checks(meta, arg...)
  34 gen_params_checks()
  35 {
  36         local meta="$1"; shift
  37         local order="$1"; shift
  38
  39         if [ "${order}" = "_release" ]; then
  40                 printf "\tkcsan_release();\n"
  41         elif [ -z "${order}" ] && ! meta_in "$meta" "slv"; then
  42                 # RMW with return value is fully ordered
  43                 printf "\tkcsan_mb();\n"
  44         fi
  45
  46         while [ "$#" -gt 0 ]; do
  47                 gen_param_check "$meta" "$1"
  48                 shift;
  49         done
  50 }
  51
  52 #gen_proto_order_variant(meta, pfx, name, sfx, order, atomic, int, arg...)
  53 gen_proto_order_variant()
  54 {
  55         local meta="$1"; shift
  56         local pfx="$1"; shift
  57         local name="$1"; shift
  58         local sfx="$1"; shift
  59         local order="$1"; shift
  60         local atomic="$1"; shift
  61         local int="$1"; shift
  62
  63         local atomicname="${atomic}_${pfx}${name}${sfx}${order}"
  64
  65         local ret="$(gen_ret_type "${meta}" "${int}")"
  66         local params="$(gen_params "${int}" "${atomic}" "$@")"
  67         local checks="$(gen_params_checks "${meta}" "${order}" "$@")"
  68         local args="$(gen_args "$@")"
  69         local retstmt="$(gen_ret_stmt "${meta}")"
  70
  71         gen_kerneldoc "" "${meta}" "${pfx}" "${name}" "${sfx}" "${order}" "${atomic}" "${int}" "$@"
  72
  73 cat <<EOF
  74 static __always_inline ${ret}
  75 ${atomicname}(${params})
  76 {
  77 ${checks}
  78         ${retstmt}raw_${atomicname}(${args});
  79 }
  80 EOF
  81
  82         printf "\n"
  83 }
  84
  85 gen_xchg()
  86 {
  87         local xchg="$1"; shift
  88         local order="$1"; shift
  89
  90         kcsan_barrier=""
  91         if [ "${xchg%_local}" = "${xchg}" ]; then
  92                 case "$order" in
  93                 _release)       kcsan_barrier="kcsan_release()" ;;
  94                 "")                     kcsan_barrier="kcsan_mb()" ;;
  95                 esac
  96         fi
  97
  98         if [ "${xchg%${xchg#try_cmpxchg}}" = "try_cmpxchg" ] ; then
  99
 100 cat <<EOF
 101 #define ${xchg}${order}(ptr, oldp, ...) \\
 102 ({ \\
 103         typeof(ptr) __ai_ptr = (ptr); \\
 104         typeof(oldp) __ai_oldp = (oldp); \\
 105 EOF
 106 [ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
 107 cat <<EOF
 108         instrument_atomic_read_write(__ai_ptr, sizeof(*__ai_ptr)); \\
 109         instrument_read_write(__ai_oldp, sizeof(*__ai_oldp)); \\
 110         raw_${xchg}${order}(__ai_ptr, __ai_oldp, __VA_ARGS__); \\
 111 })
 112 EOF
 113
 114         else
 115
 116 cat <<EOF
 117 #define ${xchg}${order}(ptr, ...) \\
 118 ({ \\
 119         typeof(ptr) __ai_ptr = (ptr); \\
 120 EOF
 121 [ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
 122 cat <<EOF
 123         instrument_atomic_read_write(__ai_ptr, sizeof(*__ai_ptr)); \\
 124         raw_${xchg}${order}(__ai_ptr, __VA_ARGS__); \\
 125 })
 126 EOF
 127
 128         fi
 129 }
 130
 131 cat << EOF
 132 // SPDX-License-Identifier: GPL-2.0
 133
 134 // Generated by $0
 135 // DO NOT MODIFY THIS FILE DIRECTLY
 136
 137 /*
 138  * This file provoides atomic operations with explicit instrumentation (e.g.
 139  * KASAN, KCSAN), which should be used unless it is necessary to avoid
 140  * instrumentation. Where it is necessary to aovid instrumenation, the
 141  * raw_atomic*() operations should be used.
 142  */
 143 #ifndef _LINUX_ATOMIC_INSTRUMENTED_H
 144 #define _LINUX_ATOMIC_INSTRUMENTED_H
 145
 146 #include <linux/build_bug.h>
 147 #include <linux/compiler.h>
 148 #include <linux/instrumented.h>
 149
 150 EOF
 151
 152 grep '^[a-z]' "$1" | while read name meta args; do
 153         gen_proto "${meta}" "${name}" "atomic" "int" ${args}
 154 done
 155
 156 grep '^[a-z]' "$1" | while read name meta args; do
 157         gen_proto "${meta}" "${name}" "atomic64" "s64" ${args}
 158 done
 159
 160 grep '^[a-z]' "$1" | while read name meta args; do
 161         gen_proto "${meta}" "${name}" "atomic_long" "long" ${args}
 162 done
 163
 164
 165 for xchg in "xchg" "cmpxchg" "cmpxchg64" "cmpxchg128" "try_cmpxchg" "try_cmpxchg64" "try_cmpxchg128"; do
 166         for order in "" "_acquire" "_release" "_relaxed"; do
 167                 gen_xchg "${xchg}" "${order}"
 168                 printf "\n"
 169         done
 170 done
 171
 172 for xchg in "cmpxchg_local" "cmpxchg64_local" "cmpxchg128_local" "sync_cmpxchg" "try_cmpxchg_local" "try_cmpxchg64_local" "try_cmpxchg128_local"; do
 173         gen_xchg "${xchg}" ""
 174         printf "\n"
 175 done
 176
 177 cat <<EOF
 178
 179 #endif /* _LINUX_ATOMIC_INSTRUMENTED_H */
 180 EOF