Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ace9bad4 authored by Mark Rutland's avatar Mark Rutland Committed by Ingo Molnar
Browse files

locking/atomics: Add common header generation files 



To minimize repetition, to allow for future rework, and to ensure
regularity of the various atomic APIs, we'd like to automatically
generate (the bulk of) a number of headers related to atomics.

This patch adds the infrastructure to do so, leaving actual conversion
of headers to subsequent patches. This infrastructure consists of:

* atomics.tbl - a table describing the functions in the atomics API,
  with names, prototypes, and metadata describing the variants that
  exist (e.g fetch/return, acquire/release/relaxed). Note that the
  return type is dependent on the particular variant.

* atomic-tbl.sh - a library of routines useful for dealing with
  atomics.tbl (e.g. querying which variants exist, or generating
  argument/parameter lists for a given function variant).

* gen-atomic-fallback.sh - a script which generates a header of
  fallbacks, covering cases where architecture omit certain functions
  (e.g. omitting relaxed variants).

* gen-atomic-long.sh - a script which generates wrappers providing the
  atomic_long API atomic of the relevant atomic or atomic64 API,
  ensuring the APIs are consistent.

* gen-atomic-instrumented.sh - a script which generates atomic* wrappers
  atop of arch_atomic* functions, with automatically generated KASAN
  instrumentation.

* fallbacks/* - a set of fallback implementations for atomics, which
  should be used when no implementation of a given atomic is provided.
  These are used by gen-atomic-fallback.sh to generate fallbacks, and
  these are also used by other scripts to determine the set of optional
  atomics (as required to generate preprocessor guards correctly).

  Fallbacks may use the following variables:

  ${atomic}     atomic prefix: atomic/atomic64/atomic_long, which can be
		used to derive the atomic type, and to prefix functions

  ${int}        integer type: int/s64/long

  ${pfx}        variant prefix, e.g. fetch_

  ${name}       base function name, e.g. add

  ${sfx}        variant suffix, e.g. _return

  ${order}      order suffix, e.g. _relaxed

  ${atomicname} full name, e.g. atomic64_fetch_add_relaxed

  ${ret}        return type of the function, e.g. void

  ${retstmt}    a return statement (with a trailing space), unless the
                variant returns void

  ${params}     parameter list for the function declaration, e.g.
                "int i, atomic_t *v"

  ${args}       argument list for invoking the function, e.g. "i, v"

  ... for clarity, ${ret}, ${retstmt}, ${params}, and ${args} are
  open-coded for fallbacks where these do not vary, or are critical to
  understanding the logic of the fallback.

The MAINTAINERS entry for the atomic infrastructure is updated to cover
the new scripts.

There should be no functional change as a result of this patch.

Signed-off-by: default avatarMark Rutland <mark.rutland@arm.com>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: linux-arm-kernel@lists.infradead.org
Cc: catalin.marinas@arm.com
Cc: Will Deacon <will.deacon@arm.com>
Cc: linuxdrivers@attotech.com
Cc: dvyukov@google.com
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: arnd@arndb.de
Cc: aryabinin@virtuozzo.com
Cc: glider@google.com
Link: http://lkml.kernel.org/r/20180904104830.2975-2-mark.rutland@arm.com


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent 01a14bda

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -2579,6 +2579,7 @@ L: linux-kernel@vger.kernel.org 
S:	Maintained

F:	arch/*/include/asm/atomic*.h

F:	include/*/atomic*.h

F:	scripts/atomic/



ATTO EXPRESSSAS SAS/SATA RAID SCSI DRIVER

M:	Bradley Grove <linuxdrivers@attotech.com>

scripts/atomic/atomic-tbl.sh

0 → 100644
+186 −0
Original line number Diff line number Diff line 
#!/bin/sh

# SPDX-License-Identifier: GPL-2.0

# helpers for dealing with atomics.tbl



#meta_in(meta, match)

meta_in()

{

	case "$1" in

	[$2]) return 0;;

	esac



	return 1

}



#meta_has_ret(meta)

meta_has_ret()

{

	meta_in "$1" "bBiIfFlR"

}



#meta_has_acquire(meta)

meta_has_acquire()

{

	meta_in "$1" "BFIlR"

}



#meta_has_release(meta)

meta_has_release()

{

	meta_in "$1" "BFIRs"

}



#meta_has_relaxed(meta)

meta_has_relaxed()

{

	meta_in "$1" "BFIR"

}



#find_fallback_template(pfx, name, sfx, order)

find_fallback_template()

{

	local pfx="$1"; shift

	local name="$1"; shift

	local sfx="$1"; shift

	local order="$1"; shift



	local base=""

	local file=""



	# We may have fallbacks for a specific case (e.g. read_acquire()), or

	# an entire class, e.g. *inc*().

	#

	# Start at the most specific, and fall back to the most general. Once

	# we find a specific fallback, don't bother looking for more.

	for base in "${pfx}${name}${sfx}${order}" "${name}"; do

		file="${ATOMICDIR}/fallbacks/${base}"



		if [ -f "${file}" ]; then

			printf "${file}"

			break

		fi

	done

}



#gen_ret_type(meta, int)

gen_ret_type() {

	local meta="$1"; shift

	local int="$1"; shift



	case "${meta}" in

	[sv]) printf "void";;

	[bB]) printf "bool";;

	[aiIfFlR]) printf "${int}";;

	esac

}



#gen_ret_stmt(meta)

gen_ret_stmt()

{

	if meta_has_ret "${meta}"; then

		printf "return ";

	fi

}



# gen_param_name(arg)

gen_param_name()

{

	# strip off the leading 'c' for 'cv'

	local name="${1#c}"

	printf "${name#*:}"

}



# gen_param_type(arg, int, atomic)

gen_param_type()

{

	local type="${1%%:*}"; shift

	local int="$1"; shift

	local atomic="$1"; shift



	case "${type}" in

	i) type="${int} ";;

	p) type="${int} *";;

	v) type="${atomic}_t *";;

	cv) type="const ${atomic}_t *";;

	esac



	printf "${type}"

}



#gen_param(arg, int, atomic)

gen_param()

{

	local arg="$1"; shift

	local int="$1"; shift

	local atomic="$1"; shift

	local name="$(gen_param_name "${arg}")"

	local type="$(gen_param_type "${arg}" "${int}" "${atomic}")"



	printf "${type}${name}"

}



#gen_params(int, atomic, arg...)

gen_params()

{

	local int="$1"; shift

	local atomic="$1"; shift



	while [ "$#" -gt 0 ]; do

		gen_param "$1" "${int}" "${atomic}"

		[ "$#" -gt 1 ] && printf ", "

		shift;

	done

}



#gen_args(arg...)

gen_args()

{

	while [ "$#" -gt 0 ]; do

		printf "$(gen_param_name "$1")"

		[ "$#" -gt 1 ] && printf ", "

		shift;

	done

}



#gen_proto_order_variants(meta, pfx, name, sfx, ...)

gen_proto_order_variants()

{

	local meta="$1"; shift

	local pfx="$1"; shift

	local name="$1"; shift

	local sfx="$1"; shift



	gen_proto_order_variant "${meta}" "${pfx}" "${name}" "${sfx}" "" "$@"



	if meta_has_acquire "${meta}"; then

		gen_proto_order_variant "${meta}" "${pfx}" "${name}" "${sfx}" "_acquire" "$@"

	fi

	if meta_has_release "${meta}"; then

		gen_proto_order_variant "${meta}" "${pfx}" "${name}" "${sfx}" "_release" "$@"

	fi

	if meta_has_relaxed "${meta}"; then

		gen_proto_order_variant "${meta}" "${pfx}" "${name}" "${sfx}" "_relaxed" "$@"

	fi

}



#gen_proto_variants(meta, name, ...)

gen_proto_variants()

{

	local meta="$1"; shift

	local name="$1"; shift

	local pfx=""

	local sfx=""



	meta_in "${meta}" "fF" && pfx="fetch_"

	meta_in "${meta}" "R" && sfx="_return"



	gen_proto_order_variants "${meta}" "${pfx}" "${name}" "${sfx}" "$@"

}



#gen_proto(meta, ...)

gen_proto() {

	local meta="$1"; shift

	for m in $(echo "${meta}" | fold -w1); do

		gen_proto_variants "${m}" "$@"

	done

}

scripts/atomic/atomics.tbl

0 → 100644
+41 −0
Original line number Diff line number Diff line 
# name	meta	args...

#

# Where meta contains a string of variants to generate.

# Upper-case implies _{acquire,release,relaxed} variants.

# Valid meta values are:

# * B/b	- bool: returns bool

# * v	- void: returns void

# * I/i	- int: returns base type

# * R	- return: returns base type (has _return variants)

# * F/f	- fetch: returns base type (has fetch_ variants)

# * l	- load: returns base type (has _acquire order variant)

# * s	- store: returns void (has _release order variant)

#

# Where args contains list of type[:name], where type is:

# * cv	- const pointer to atomic base type (atomic_t/atomic64_t/atomic_long_t)

# * v	- pointer to atomic base type (atomic_t/atomic64_t/atomic_long_t)

# * i	- base type (int/s64/long)

# * p	- pointer to base type (int/s64/long)

#

read			l	cv

set			s	v	i

add			vRF	i	v

sub			vRF	i	v

inc			vRF	v

dec			vRF	v

and			vF	i	v

andnot			vF	i	v

or			vF	i	v

xor			vF	i	v

xchg			I	v	i

cmpxchg			I	v	i:old	i:new

try_cmpxchg		B	v	p:old	i:new

sub_and_test		b	i	v

dec_and_test		b	v

inc_and_test		b	v

add_negative		b	i	v

add_unless		fb	v	i:a	i:u

inc_not_zero		b	v

inc_unless_negative	b	v

dec_unless_positive	b	v

dec_if_positive		i	v

scripts/atomic/fallbacks/acquire

0 → 100644
+9 −0
Original line number Diff line number Diff line 
cat <<EOF

static inline ${ret}

${atomic}_${pfx}${name}${sfx}_acquire(${params})

{

	${ret} ret = ${atomic}_${pfx}${name}${sfx}_relaxed(${args});

	__atomic_acquire_fence();

	return ret;

}

EOF

scripts/atomic/fallbacks/add_negative

0 → 100644
+16 −0
Original line number Diff line number Diff line 
cat <<EOF

/**

 * ${atomic}_add_negative - add and test if negative

 * @i: integer value to add

 * @v: pointer of type ${atomic}_t

 *

 * Atomically adds @i to @v and returns true

 * if the result is negative, or false when

 * result is greater than or equal to zero.

 */

static inline bool

${atomic}_add_negative(${int} i, ${atomic}_t *v)

{

	return ${atomic}_add_return(i, v) < 0;

}

EOF