mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Mark Rutland](/assets/img/avatar_default.png)
Currently the atomics are documented in Documentation/atomic_t.txt, and have no kerneldoc comments. There are a sufficient number of gotchas (e.g. semantics, noinstr-safety) that it would be nice to have comments to call these out, and it would be nice to have kerneldoc comments such that these can be collated. While it's possible to derive the semantics from the code, this can be painful given the amount of indirection we currently have (e.g. fallback paths), and it's easy to be mislead by naming, e.g. * The unconditional void-returning ops *only* have relaxed variants without a _relaxed suffix, and can easily be mistaken for being fully ordered. It would be nice to give these a _relaxed() suffix, but this would result in significant churn throughout the kernel. * Our naming of conditional and unconditional+test ops is rather inconsistent, and it can be difficult to derive the name of an operation, or to identify where an op is conditional or unconditional+test. Some ops are clearly conditional: - dec_if_positive - add_unless - dec_unless_positive - inc_unless_negative Some ops are clearly unconditional+test: - sub_and_test - dec_and_test - inc_and_test However, what exactly those test is not obvious. A _test_zero suffix might be clearer. Others could be read ambiguously: - inc_not_zero // conditional - add_negative // unconditional+test It would probably be worth renaming these, e.g. to inc_unless_zero and add_test_negative. As a step towards making this more consistent and easier to understand, this patch adds kerneldoc comments for all generated *atomic*_*() functions. These are generated from templates, with some common text shared, making it easy to extend these in future if necessary. I've tried to make these as consistent and clear as possible, and I've deliberately ensured: * All ops have their ordering explicitly mentioned in the short and long description. * All test ops have "test" in their short description. * All ops are described as an expression using their usual C operator. For example: andnot: "Atomically updates @v to (@v & ~@i)" inc: "Atomically updates @v to (@v + 1)" Which may be clearer to non-naative English speakers, and allows all the operations to be described in the same style. * All conditional ops have their condition described as an expression using the usual C operators. For example: add_unless: "If (@v != @u), atomically updates @v to (@v + @i)" cmpxchg: "If (@v == @old), atomically updates @v to @new" Which may be clearer to non-naative English speakers, and allows all the operations to be described in the same style. * All bitwise ops (and,andnot,or,xor) explicitly mention that they are bitwise in their short description, so that they are not mistaken for performing their logical equivalents. * The noinstr safety of each op is explicitly described, with a description of whether or not to use the raw_ form of the op. There should be no functional change as a result of this patch. Reported-by: Paul E. McKenney <paulmck@kernel.org> Signed-off-by: Mark Rutland <mark.rutland@arm.com> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> Reviewed-by: Kees Cook <keescook@chromium.org> Link: https://lore.kernel.org/r/20230605070124.3741859-26-mark.rutland@arm.com
180 lines
4.1 KiB
Bash
Executable file
180 lines
4.1 KiB
Bash
Executable file
#!/bin/sh
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
|
|
ATOMICDIR=$(dirname $0)
|
|
|
|
. ${ATOMICDIR}/atomic-tbl.sh
|
|
|
|
#gen_param_check(meta, arg)
|
|
gen_param_check()
|
|
{
|
|
local meta="$1"; shift
|
|
local arg="$1"; shift
|
|
local type="${arg%%:*}"
|
|
local name="$(gen_param_name "${arg}")"
|
|
local rw="write"
|
|
|
|
case "${type#c}" in
|
|
i) return;;
|
|
esac
|
|
|
|
if [ ${type#c} != ${type} ]; then
|
|
# We don't write to constant parameters.
|
|
rw="read"
|
|
elif [ "${meta}" != "s" ]; then
|
|
# An atomic RMW: if this parameter is not a constant, and this atomic is
|
|
# not just a 's'tore, this parameter is both read from and written to.
|
|
rw="read_write"
|
|
fi
|
|
|
|
printf "\tinstrument_atomic_${rw}(${name}, sizeof(*${name}));\n"
|
|
}
|
|
|
|
#gen_params_checks(meta, arg...)
|
|
gen_params_checks()
|
|
{
|
|
local meta="$1"; shift
|
|
local order="$1"; shift
|
|
|
|
if [ "${order}" = "_release" ]; then
|
|
printf "\tkcsan_release();\n"
|
|
elif [ -z "${order}" ] && ! meta_in "$meta" "slv"; then
|
|
# RMW with return value is fully ordered
|
|
printf "\tkcsan_mb();\n"
|
|
fi
|
|
|
|
while [ "$#" -gt 0 ]; do
|
|
gen_param_check "$meta" "$1"
|
|
shift;
|
|
done
|
|
}
|
|
|
|
#gen_proto_order_variant(meta, pfx, name, sfx, order, atomic, int, arg...)
|
|
gen_proto_order_variant()
|
|
{
|
|
local meta="$1"; shift
|
|
local pfx="$1"; shift
|
|
local name="$1"; shift
|
|
local sfx="$1"; shift
|
|
local order="$1"; shift
|
|
local atomic="$1"; shift
|
|
local int="$1"; shift
|
|
|
|
local atomicname="${atomic}_${pfx}${name}${sfx}${order}"
|
|
|
|
local ret="$(gen_ret_type "${meta}" "${int}")"
|
|
local params="$(gen_params "${int}" "${atomic}" "$@")"
|
|
local checks="$(gen_params_checks "${meta}" "${order}" "$@")"
|
|
local args="$(gen_args "$@")"
|
|
local retstmt="$(gen_ret_stmt "${meta}")"
|
|
|
|
gen_kerneldoc "" "${meta}" "${pfx}" "${name}" "${sfx}" "${order}" "${atomic}" "${int}" "$@"
|
|
|
|
cat <<EOF
|
|
static __always_inline ${ret}
|
|
${atomicname}(${params})
|
|
{
|
|
${checks}
|
|
${retstmt}raw_${atomicname}(${args});
|
|
}
|
|
EOF
|
|
|
|
printf "\n"
|
|
}
|
|
|
|
gen_xchg()
|
|
{
|
|
local xchg="$1"; shift
|
|
local order="$1"; shift
|
|
|
|
kcsan_barrier=""
|
|
if [ "${xchg%_local}" = "${xchg}" ]; then
|
|
case "$order" in
|
|
_release) kcsan_barrier="kcsan_release()" ;;
|
|
"") kcsan_barrier="kcsan_mb()" ;;
|
|
esac
|
|
fi
|
|
|
|
if [ "${xchg%${xchg#try_cmpxchg}}" = "try_cmpxchg" ] ; then
|
|
|
|
cat <<EOF
|
|
#define ${xchg}${order}(ptr, oldp, ...) \\
|
|
({ \\
|
|
typeof(ptr) __ai_ptr = (ptr); \\
|
|
typeof(oldp) __ai_oldp = (oldp); \\
|
|
EOF
|
|
[ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
|
|
cat <<EOF
|
|
instrument_atomic_read_write(__ai_ptr, sizeof(*__ai_ptr)); \\
|
|
instrument_read_write(__ai_oldp, sizeof(*__ai_oldp)); \\
|
|
raw_${xchg}${order}(__ai_ptr, __ai_oldp, __VA_ARGS__); \\
|
|
})
|
|
EOF
|
|
|
|
else
|
|
|
|
cat <<EOF
|
|
#define ${xchg}${order}(ptr, ...) \\
|
|
({ \\
|
|
typeof(ptr) __ai_ptr = (ptr); \\
|
|
EOF
|
|
[ -n "$kcsan_barrier" ] && printf "\t${kcsan_barrier}; \\\\\n"
|
|
cat <<EOF
|
|
instrument_atomic_read_write(__ai_ptr, sizeof(*__ai_ptr)); \\
|
|
raw_${xchg}${order}(__ai_ptr, __VA_ARGS__); \\
|
|
})
|
|
EOF
|
|
|
|
fi
|
|
}
|
|
|
|
cat << EOF
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
// Generated by $0
|
|
// DO NOT MODIFY THIS FILE DIRECTLY
|
|
|
|
/*
|
|
* This file provoides atomic operations with explicit instrumentation (e.g.
|
|
* KASAN, KCSAN), which should be used unless it is necessary to avoid
|
|
* instrumentation. Where it is necessary to aovid instrumenation, the
|
|
* raw_atomic*() operations should be used.
|
|
*/
|
|
#ifndef _LINUX_ATOMIC_INSTRUMENTED_H
|
|
#define _LINUX_ATOMIC_INSTRUMENTED_H
|
|
|
|
#include <linux/build_bug.h>
|
|
#include <linux/compiler.h>
|
|
#include <linux/instrumented.h>
|
|
|
|
EOF
|
|
|
|
grep '^[a-z]' "$1" | while read name meta args; do
|
|
gen_proto "${meta}" "${name}" "atomic" "int" ${args}
|
|
done
|
|
|
|
grep '^[a-z]' "$1" | while read name meta args; do
|
|
gen_proto "${meta}" "${name}" "atomic64" "s64" ${args}
|
|
done
|
|
|
|
grep '^[a-z]' "$1" | while read name meta args; do
|
|
gen_proto "${meta}" "${name}" "atomic_long" "long" ${args}
|
|
done
|
|
|
|
|
|
for xchg in "xchg" "cmpxchg" "cmpxchg64" "cmpxchg128" "try_cmpxchg" "try_cmpxchg64" "try_cmpxchg128"; do
|
|
for order in "" "_acquire" "_release" "_relaxed"; do
|
|
gen_xchg "${xchg}" "${order}"
|
|
printf "\n"
|
|
done
|
|
done
|
|
|
|
for xchg in "cmpxchg_local" "cmpxchg64_local" "cmpxchg128_local" "sync_cmpxchg" "try_cmpxchg_local" "try_cmpxchg64_local" "try_cmpxchg128_local"; do
|
|
gen_xchg "${xchg}" ""
|
|
printf "\n"
|
|
done
|
|
|
|
cat <<EOF
|
|
|
|
#endif /* _LINUX_ATOMIC_INSTRUMENTED_H */
|
|
EOF
|