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(arg)
   9 gen_param_check()
  10 {
  11         local arg="$1"; shift
  12         local type="${arg%%:*}"
  13         local name="$(gen_param_name "${arg}")"
  14         local rw="write"
  15
  16         case "${type#c}" in
  17         i) return;;
  18         esac
  19
  20         # We don't write to constant parameters
  21         [ ${type#c} != ${type} ] && rw="read"
  22
  23         printf "\tkasan_check_${rw}(${name}, sizeof(*${name}));\n"
  24 }
  25
  26 #gen_param_check(arg...)
  27 gen_params_checks()
  28 {
  29         while [ "$#" -gt 0 ]; do
  30                 gen_param_check "$1"
  31                 shift;
  32         done
  33 }
  34
  35 # gen_guard(meta, atomic, pfx, name, sfx, order)
  36 gen_guard()
  37 {
  38         local meta="$1"; shift
  39         local atomic="$1"; shift
  40         local pfx="$1"; shift
  41         local name="$1"; shift
  42         local sfx="$1"; shift
  43         local order="$1"; shift
  44
  45         local atomicname="arch_${atomic}_${pfx}${name}${sfx}${order}"
  46
  47         local template="$(find_fallback_template "${pfx}" "${name}" "${sfx}" "${order}")"
  48
  49         # We definitely need a preprocessor symbol for this atomic if it is an
  50         # ordering variant, or if there's a generic fallback.
  51         if [ ! -z "${order}" ] || [ ! -z "${template}" ]; then
  52                 printf "defined(${atomicname})"
  53                 return
  54         fi
  55
  56         # If this is a base variant, but a relaxed variant *may* exist, then we
  57         # only have a preprocessor symbol if the relaxed variant isn't defined
  58         if meta_has_relaxed "${meta}"; then
  59                 printf "!defined(${atomicname}_relaxed) || defined(${atomicname})"
  60         fi
  61 }
  62
  63 #gen_proto_order_variant(meta, pfx, name, sfx, order, atomic, int, arg...)
  64 gen_proto_order_variant()
  65 {
  66         local meta="$1"; shift
  67         local pfx="$1"; shift
  68         local name="$1"; shift
  69         local sfx="$1"; shift
  70         local order="$1"; shift
  71         local atomic="$1"; shift
  72         local int="$1"; shift
  73
  74         local atomicname="${atomic}_${pfx}${name}${sfx}${order}"
  75
  76         local guard="$(gen_guard "${meta}" "${atomic}" "${pfx}" "${name}" "${sfx}" "${order}")"
  77
  78         local ret="$(gen_ret_type "${meta}" "${int}")"
  79         local params="$(gen_params "${int}" "${atomic}" "$@")"
  80         local checks="$(gen_params_checks "$@")"
  81         local args="$(gen_args "$@")"
  82         local retstmt="$(gen_ret_stmt "${meta}")"
  83
  84         [ ! -z "${guard}" ] && printf "#if ${guard}\n"
  85
  86 cat <<EOF
  87 static inline ${ret}
  88 ${atomicname}(${params})
  89 {
  90 ${checks}
  91         ${retstmt}arch_${atomicname}(${args});
  92 }
  93 #define ${atomicname} ${atomicname}
  94 EOF
  95
  96         [ ! -z "${guard}" ] && printf "#endif\n"
  97
  98         printf "\n"
  99 }
 100
 101 gen_xchg()
 102 {
 103         local xchg="$1"; shift
 104         local mult="$1"; shift
 105
 106 cat <<EOF
 107 #define ${xchg}(ptr, ...)                                               \\
 108 ({                                                                      \\
 109         typeof(ptr) __ai_ptr = (ptr);                                   \\
 110         kasan_check_write(__ai_ptr, ${mult}sizeof(*__ai_ptr));          \\
 111         arch_${xchg}(__ai_ptr, __VA_ARGS__);                            \\
 112 })
 113 EOF
 114 }
 115
 116 gen_optional_xchg()
 117 {
 118         local name="$1"; shift
 119         local sfx="$1"; shift
 120         local guard="defined(arch_${name}${sfx})"
 121
 122         [ -z "${sfx}" ] && guard="!defined(arch_${name}_relaxed) || defined(arch_${name})"
 123
 124         printf "#if ${guard}\n"
 125         gen_xchg "${name}${sfx}" ""
 126         printf "#endif\n\n"
 127 }
 128
 129 cat << EOF
 130 // SPDX-License-Identifier: GPL-2.0
 131
 132 // Generated by $0
 133 // DO NOT MODIFY THIS FILE DIRECTLY
 134
 135 /*
 136  * This file provides wrappers with KASAN instrumentation for atomic operations.
 137  * To use this functionality an arch's atomic.h file needs to define all
 138  * atomic operations with arch_ prefix (e.g. arch_atomic_read()) and include
 139  * this file at the end. This file provides atomic_read() that forwards to
 140  * arch_atomic_read() for actual atomic operation.
 141  * Note: if an arch atomic operation is implemented by means of other atomic
 142  * operations (e.g. atomic_read()/atomic_cmpxchg() loop), then it needs to use
 143  * arch_ variants (i.e. arch_atomic_read()/arch_atomic_cmpxchg()) to avoid
 144  * double instrumentation.
 145  */
 146 #ifndef _ASM_GENERIC_ATOMIC_INSTRUMENTED_H
 147 #define _ASM_GENERIC_ATOMIC_INSTRUMENTED_H
 148
 149 #include <linux/build_bug.h>
 150 #include <linux/kasan-checks.h>
 151
 152 EOF
 153
 154 grep '^[a-z]' "$1" | while read name meta args; do
 155         gen_proto "${meta}" "${name}" "atomic" "int" ${args}
 156 done
 157
 158 grep '^[a-z]' "$1" | while read name meta args; do
 159         gen_proto "${meta}" "${name}" "atomic64" "s64" ${args}
 160 done
 161
 162 for xchg in "xchg" "cmpxchg" "cmpxchg64"; do
 163         for order in "" "_acquire" "_release" "_relaxed"; do
 164                 gen_optional_xchg "${xchg}" "${order}"
 165         done
 166 done
 167
 168 for xchg in "cmpxchg_local" "cmpxchg64_local" "sync_cmpxchg"; do
 169         gen_xchg "${xchg}" ""
 170         printf "\n"
 171 done
 172
 173 gen_xchg "cmpxchg_double" "2 * "
 174
 175 printf "\n\n"
 176
 177 gen_xchg "cmpxchg_double_local" "2 * "
 178
 179 cat <<EOF
 180
 181 #endif /* _ASM_GENERIC_ATOMIC_INSTRUMENTED_H */
 182 EOF