Loading...
1#!/bin/sh
2# SPDX-License-Identifier: GPL-2.0
3
4ATOMICDIR=$(dirname $0)
5
6. ${ATOMICDIR}/atomic-tbl.sh
7
8#gen_param_check(meta, arg)
9gen_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...)
34gen_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...)
53gen_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
73cat <<EOF
74static __always_inline ${ret}
75${atomicname}(${params})
76{
77${checks}
78 ${retstmt}raw_${atomicname}(${args});
79}
80EOF
81
82 printf "\n"
83}
84
85gen_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
100cat <<EOF
101#define ${xchg}${order}(ptr, oldp, ...) \\
102({ \\
103 typeof(ptr) __ai_ptr = (ptr); \\
104 typeof(oldp) __ai_oldp = (oldp); \\
105EOF
106[ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
107cat <<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})
112EOF
113
114 else
115
116cat <<EOF
117#define ${xchg}${order}(ptr, ...) \\
118({ \\
119 typeof(ptr) __ai_ptr = (ptr); \\
120EOF
121[ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
122cat <<EOF
123 instrument_atomic_read_write(__ai_ptr, sizeof(*__ai_ptr)); \\
124 raw_${xchg}${order}(__ai_ptr, __VA_ARGS__); \\
125})
126EOF
127
128 fi
129}
130
131cat << 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
150EOF
151
152grep '^[a-z]' "$1" | while read name meta args; do
153 gen_proto "${meta}" "${name}" "atomic" "int" ${args}
154done
155
156grep '^[a-z]' "$1" | while read name meta args; do
157 gen_proto "${meta}" "${name}" "atomic64" "s64" ${args}
158done
159
160grep '^[a-z]' "$1" | while read name meta args; do
161 gen_proto "${meta}" "${name}" "atomic_long" "long" ${args}
162done
163
164
165for 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
170done
171
172for xchg in "cmpxchg_local" "cmpxchg64_local" "cmpxchg128_local" "sync_cmpxchg" \
173 "try_cmpxchg_local" "try_cmpxchg64_local" "try_cmpxchg128_local" "sync_try_cmpxchg"; do
174 gen_xchg "${xchg}" ""
175 printf "\n"
176done
177
178cat <<EOF
179
180#endif /* _LINUX_ATOMIC_INSTRUMENTED_H */
181EOF
1#!/bin/sh
2# SPDX-License-Identifier: GPL-2.0
3
4ATOMICDIR=$(dirname $0)
5
6. ${ATOMICDIR}/atomic-tbl.sh
7
8#gen_param_check(arg)
9gen_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...)
27gen_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)
36gen_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...)
64gen_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
86cat <<EOF
87static inline ${ret}
88${atomicname}(${params})
89{
90${checks}
91 ${retstmt}arch_${atomicname}(${args});
92}
93#define ${atomicname} ${atomicname}
94EOF
95
96 [ ! -z "${guard}" ] && printf "#endif\n"
97
98 printf "\n"
99}
100
101gen_xchg()
102{
103 local xchg="$1"; shift
104 local mult="$1"; shift
105
106cat <<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})
113EOF
114}
115
116gen_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
129cat << 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
152EOF
153
154grep '^[a-z]' "$1" | while read name meta args; do
155 gen_proto "${meta}" "${name}" "atomic" "int" ${args}
156done
157
158grep '^[a-z]' "$1" | while read name meta args; do
159 gen_proto "${meta}" "${name}" "atomic64" "s64" ${args}
160done
161
162for xchg in "xchg" "cmpxchg" "cmpxchg64"; do
163 for order in "" "_acquire" "_release" "_relaxed"; do
164 gen_optional_xchg "${xchg}" "${order}"
165 done
166done
167
168for xchg in "cmpxchg_local" "cmpxchg64_local" "sync_cmpxchg"; do
169 gen_xchg "${xchg}" ""
170 printf "\n"
171done
172
173gen_xchg "cmpxchg_double" "2 * "
174
175printf "\n\n"
176
177gen_xchg "cmpxchg_double_local" "2 * "
178
179cat <<EOF
180
181#endif /* _ASM_GENERIC_ATOMIC_INSTRUMENTED_H */
182EOF