scripts/check-uapi.sh - linux - Git at Google

 #!/bin/bash
 # SPDX-License-Identifier: GPL-2.0-only
 # Script to check commits for UAPI backwards compatibility

 set -o errexit
 set -o pipefail

 print_usage() {
 	name=$(basename "$0")
 	cat << EOF
 $name - check for UAPI header stability across Git commits

 By default, the script will check to make sure the latest commit (or current
 dirty changes) did not introduce ABI changes when compared to HEAD^1. You can
 check against additional commit ranges with the -b and -p options.

 The script will not check UAPI headers for architectures other than the one
 defined in ARCH.

 Usage: $name [-b BASE_REF] [-p PAST_REF] [-j N] [-l ERROR_LOG] [-i] [-q] [-v]

 Options:
     -b BASE_REF    Base git reference to use for comparison. If unspecified or empty,
                    will use any dirty changes in tree to UAPI files. If there are no
                    dirty changes, HEAD will be used.
     -p PAST_REF    Compare BASE_REF to PAST_REF (e.g. -p v6.1). If unspecified or empty,
                    will use BASE_REF^1. Must be an ancestor of BASE_REF. Only headers
                    that exist on PAST_REF will be checked for compatibility.
     -j JOBS        Number of checks to run in parallel (default: number of CPU cores).
     -l ERROR_LOG   Write error log to file (default: no error log is generated).
     -i             Ignore ambiguous changes that may or may not break UAPI compatibility.
     -q             Quiet operation.
     -v             Verbose operation (print more information about each header being checked).

 Environmental args:
     ABIDIFF  Custom path to abidiff binary
     CC       C compiler (default is "gcc")
     ARCH     Target architecture for the UAPI check (default is host arch)

 Exit codes:
     $SUCCESS) Success
     $FAIL_ABI) ABI difference detected
     $FAIL_PREREQ) Prerequisite not met
 EOF
 }

 readonly SUCCESS=0
 readonly FAIL_ABI=1
 readonly FAIL_PREREQ=2

 # Print to stderr
 eprintf() {
 	# shellcheck disable=SC2059
 	printf "$@" >&2
 }

 # Expand an array with a specific character (similar to Python string.join())
 join() {
 	local IFS="$1"
 	shift
 	printf "%s" "$*"
 }

 # Create abidiff suppressions
 gen_suppressions() {
 	# Common enum variant names which we don't want to worry about
 	# being shifted when new variants are added.
 	local -a enum_regex=(
 		".*_AFTER_LAST$"
 		".*_CNT$"
 		".*_COUNT$"
 		".*_END$"
 		".*_LAST$"
 		".*_MASK$"
 		".*_MAX$"
 		".*_MAX_BIT$"
 		".*_MAX_BPF_ATTACH_TYPE$"
 		".*_MAX_ID$"
 		".*_MAX_SHIFT$"
 		".*_NBITS$"
 		".*_NETDEV_NUMHOOKS$"
 		".*_NFT_META_IIFTYPE$"
 		".*_NL80211_ATTR$"
 		".*_NLDEV_NUM_OPS$"
 		".*_NUM$"
 		".*_NUM_ELEMS$"
 		".*_NUM_IRQS$"
 		".*_SIZE$"
 		".*_TLSMAX$"
 		"^MAX_.*"
 		"^NUM_.*"
 	)

 	# Common padding field names which can be expanded into
 	# without worrying about users.
 	local -a padding_regex=(
 		".*end$"
 		".*pad$"
 		".*pad[0-9]?$"
 		".*pad_[0-9]?$"
 		".*padding$"
 		".*padding[0-9]?$"
 		".*padding_[0-9]?$"
 		".*res$"
 		".*resv$"
 		".*resv[0-9]?$"
 		".*resv_[0-9]?$"
 		".*reserved$"
 		".*reserved[0-9]?$"
 		".*reserved_[0-9]?$"
 		".*rsvd[0-9]?$"
 		".*unused$"
 	)

 	cat << EOF
 [suppress_type]
   type_kind = enum
   changed_enumerators_regexp = $(join , "${enum_regex[@]}")
 EOF

 	for p in "${padding_regex[@]}"; do
 		cat << EOF
 [suppress_type]
   type_kind = struct
   has_data_member_inserted_at = offset_of_first_data_member_regexp(${p})
 EOF
 	done

 if [ "$IGNORE_AMBIGUOUS_CHANGES" = "true" ]; then
 	cat << EOF
 [suppress_type]
   type_kind = struct
   has_data_member_inserted_at = end
   has_size_change = yes
 EOF
 fi
 }

 # Check if git tree is dirty
 tree_is_dirty() {
 	! git diff --quiet
 }

 # Get list of files installed in $ref
 get_file_list() {
 	local -r ref="$1"
 	local -r tree="$(get_header_tree "$ref")"

 	# Print all installed headers, filtering out ones that can't be compiled
 	find "$tree" -type f -name '*.h' -printf '%P\n' | grep -v -f "$INCOMPAT_LIST"
 }

 # Add to the list of incompatible headers
 add_to_incompat_list() {
 	local -r ref="$1"

 	# Start with the usr/include/Makefile to get a list of the headers
 	# that don't compile using this method.
 	if [ ! -f usr/include/Makefile ]; then
 		eprintf "error - no usr/include/Makefile present at %s\n" "$ref"
 		eprintf "Note: usr/include/Makefile was added in the v5.3 kernel release\n"
 		exit "$FAIL_PREREQ"
 	fi
 	{
 		# shellcheck disable=SC2016
 		printf 'all: ; @echo $(no-header-test)\n'
 		cat usr/include/Makefile
 	} | SRCARCH="$ARCH" make --always-make -f - | tr " " "\n" \
 	  | grep -v "asm-generic" >> "$INCOMPAT_LIST"

 	# The makefile also skips all asm-generic files, but prints "asm-generic/%"
 	# which won't work for our grep match. Instead, print something grep will match.
 	printf "asm-generic/.*\.h\n" >> "$INCOMPAT_LIST"
 }

 # Compile the simple test app
 do_compile() {
 	local -r inc_dir="$1"
 	local -r header="$2"
 	local -r out="$3"
 	printf "int main(void) { return 0; }\n" | \
 		"$CC" -c \
 		  -o "$out" \
 		  -x c \
 		  -O0 \
 		  -std=c90 \
 		  -fno-eliminate-unused-debug-types \
 		  -g \
 		  "-I${inc_dir}" \
 		  -include "$header" \
 		  -
 }

 # Run make headers_install
 run_make_headers_install() {
 	local -r ref="$1"
 	local -r install_dir="$(get_header_tree "$ref")"
 	make -j "$MAX_THREADS" ARCH="$ARCH" INSTALL_HDR_PATH="$install_dir" \
 		headers_install > /dev/null
 }

 # Install headers for both git refs
 install_headers() {
 	local -r base_ref="$1"
 	local -r past_ref="$2"

 	for ref in "$base_ref" "$past_ref"; do
 		printf "Installing user-facing UAPI headers from %s... " "${ref:-dirty tree}"
 		if [ -n "$ref" ]; then
 			git archive --format=tar --prefix="${ref}-archive/" "$ref" \
 				| (cd "$TMP_DIR" && tar xf -)
 			(
 				cd "${TMP_DIR}/${ref}-archive"
 				run_make_headers_install "$ref"
 				add_to_incompat_list "$ref" "$INCOMPAT_LIST"
 			)
 		else
 			run_make_headers_install "$ref"
 			add_to_incompat_list "$ref" "$INCOMPAT_LIST"
 		fi
 		printf "OK\n"
 	done
 	sort -u -o "$INCOMPAT_LIST" "$INCOMPAT_LIST"
 	sed -i -e '/^$/d' "$INCOMPAT_LIST"
 }

 # Print the path to the headers_install tree for a given ref
 get_header_tree() {
 	local -r ref="$1"
 	printf "%s" "${TMP_DIR}/${ref}/usr"
 }

 # Check file list for UAPI compatibility
 check_uapi_files() {
 	local -r base_ref="$1"
 	local -r past_ref="$2"
 	local -r abi_error_log="$3"

 	local passed=0;
 	local failed=0;
 	local -a threads=()
 	set -o errexit

 	printf "Checking changes to UAPI headers between %s and %s...\n" "$past_ref" "${base_ref:-dirty tree}"
 	# Loop over all UAPI headers that were installed by $past_ref (if they only exist on $base_ref,
 	# there's no way they're broken and no way to compare anyway)
 	while read -r file; do
 		if [ "${#threads[@]}" -ge "$MAX_THREADS" ]; then
 			if wait "${threads[0]}"; then
 				passed=$((passed + 1))
 			else
 				failed=$((failed + 1))
 			fi
 			threads=("${threads[@]:1}")
 		fi

 		check_individual_file "$base_ref" "$past_ref" "$file" &
 		threads+=("$!")
 	done < <(get_file_list "$past_ref")

 	for t in "${threads[@]}"; do
 		if wait "$t"; then
 			passed=$((passed + 1))
 		else
 			failed=$((failed + 1))
 		fi
 	done

 	if [ -n "$abi_error_log" ]; then
 		printf 'Generated by "%s %s" from git ref %s\n\n' \
 			"$0" "$*" "$(git rev-parse HEAD)" > "$abi_error_log"
 	fi

 	while read -r error_file; do
 		{
 			cat "$error_file"
 			printf "\n\n"
 		} | tee -a "${abi_error_log:-/dev/null}" >&2
 	done < <(find "$TMP_DIR" -type f -name '*.error' | sort)

 	total="$((passed + failed))"
 	if [ "$failed" -gt 0 ]; then
 		eprintf "error - %d/%d UAPI headers compatible with %s appear _not_ to be backwards compatible\n" \
 			"$failed" "$total" "$ARCH"
 		if [ -n "$abi_error_log" ]; then
 			eprintf "Failure summary saved to %s\n" "$abi_error_log"
 		fi
 	else
 		printf "All %d UAPI headers compatible with %s appear to be backwards compatible\n" \
 			"$total" "$ARCH"
 	fi

 	return "$failed"
 }

 # Check an individual file for UAPI compatibility
 check_individual_file() {
 	local -r base_ref="$1"
 	local -r past_ref="$2"
 	local -r file="$3"

 	local -r base_header="$(get_header_tree "$base_ref")/${file}"
 	local -r past_header="$(get_header_tree "$past_ref")/${file}"

 	if [ ! -f "$base_header" ]; then
 		mkdir -p "$(dirname "$base_header")"
 		printf "==== UAPI header %s was removed between %s and %s ====" \
 			"$file" "$past_ref" "$base_ref" \
 				> "${base_header}.error"
 		return 1
 	fi

 	compare_abi "$file" "$base_header" "$past_header" "$base_ref" "$past_ref"
 }

 # Perform the A/B compilation and compare output ABI
 compare_abi() {
 	local -r file="$1"
 	local -r base_header="$2"
 	local -r past_header="$3"
 	local -r base_ref="$4"
 	local -r past_ref="$5"
 	local -r log="${TMP_DIR}/log/${file}.log"
 	local -r error_log="${TMP_DIR}/log/${file}.error"

 	mkdir -p "$(dirname "$log")"

 	if ! do_compile "$(get_header_tree "$base_ref")/include" "$base_header" "${base_header}.bin" 2> "$log"; then
 		{
 			warn_str=$(printf "==== Could not compile version of UAPI header %s at %s ====\n" \
 				"$file" "$base_ref")
 			printf "%s\n" "$warn_str"
 			cat "$log"
 			printf -- "=%.0s" $(seq 0 ${#warn_str})
 		} > "$error_log"
 		return 1
 	fi

 	if ! do_compile "$(get_header_tree "$past_ref")/include" "$past_header" "${past_header}.bin" 2> "$log"; then
 		{
 			warn_str=$(printf "==== Could not compile version of UAPI header %s at %s ====\n" \
 				"$file" "$past_ref")
 			printf "%s\n" "$warn_str"
 			cat "$log"
 			printf -- "=%.0s" $(seq 0 ${#warn_str})
 		} > "$error_log"
 		return 1
 	fi

 	local ret=0
 	"$ABIDIFF" --non-reachable-types \
 		--suppressions "$SUPPRESSIONS" \
 		"${past_header}.bin" "${base_header}.bin" > "$log" || ret="$?"
 	if [ "$ret" -eq 0 ]; then
 		if [ "$VERBOSE" = "true" ]; then
 			printf "No ABI differences detected in %s from %s -> %s\n" \
 				"$file" "$past_ref" "$base_ref"
 		fi
 	else
 		# Bits in abidiff's return code can be used to determine the type of error
 		if [ $((ret & 0x2)) -gt 0 ]; then
 			eprintf "error - abidiff did not run properly\n"
 			exit 1
 		fi

 		if [ "$IGNORE_AMBIGUOUS_CHANGES" = "true" ] && [ "$ret" -eq 4 ]; then
 			return 0
 		fi

 		# If the only changes were additions (not modifications to existing APIs), then
 		# there's no problem. Ignore these diffs.
 		if grep "Unreachable types summary" "$log" | grep -q "0 removed" &&
 		   grep "Unreachable types summary" "$log" | grep -q "0 changed"; then
 			return 0
 		fi

 		{
 			warn_str=$(printf "==== ABI differences detected in %s from %s -> %s ====" \
 				"$file" "$past_ref" "$base_ref")
 			printf "%s\n" "$warn_str"
 			sed  -e '/summary:/d' -e '/changed type/d' -e '/^$/d' -e 's/^/  /g' "$log"
 			printf -- "=%.0s" $(seq 0 ${#warn_str})
 			if cmp "$past_header" "$base_header" > /dev/null 2>&1; then
 				printf "\n%s did not change between %s and %s...\n" "$file" "$past_ref" "${base_ref:-dirty tree}"
 				printf "It's possible a change to one of the headers it includes caused this error:\n"
 				grep '^#include' "$base_header"
 				printf "\n"
 			fi
 		} > "$error_log"

 		return 1
 	fi
 }

 # Check that a minimum software version number is satisfied
 min_version_is_satisfied() {
 	local -r min_version="$1"
 	local -r version_installed="$2"

 	printf "%s\n%s\n" "$min_version" "$version_installed" \
 		| sort -Vc > /dev/null 2>&1
 }

 # Make sure we have the tools we need and the arguments make sense
 check_deps() {
 	ABIDIFF="${ABIDIFF:-abidiff}"
 	CC="${CC:-gcc}"
 	ARCH="${ARCH:-$(uname -m)}"
 	if [ "$ARCH" = "x86_64" ]; then
 		ARCH="x86"
 	fi

 	local -r abidiff_min_version="2.4"
 	local -r libdw_min_version_if_clang="0.171"

 	if ! command -v "$ABIDIFF" > /dev/null 2>&1; then
 		eprintf "error - abidiff not found!\n"
 		eprintf "Please install abigail-tools version %s or greater\n" "$abidiff_min_version"
 		eprintf "See: https://sourceware.org/libabigail/manual/libabigail-overview.html\n"
 		return 1
 	fi

 	local -r abidiff_version="$("$ABIDIFF" --version | cut -d ' ' -f 2)"
 	if ! min_version_is_satisfied "$abidiff_min_version" "$abidiff_version"; then
 		eprintf "error - abidiff version too old: %s\n" "$abidiff_version"
 		eprintf "Please install abigail-tools version %s or greater\n" "$abidiff_min_version"
 		eprintf "See: https://sourceware.org/libabigail/manual/libabigail-overview.html\n"
 		return 1
 	fi

 	if ! command -v "$CC" > /dev/null 2>&1; then
 		eprintf 'error - %s not found\n' "$CC"
 		return 1
 	fi

 	if "$CC" --version | grep -q clang; then
 		local -r libdw_version="$(ldconfig -v 2>/dev/null | grep -v SKIPPED | grep -m 1 -o 'libdw-[0-9]\+.[0-9]\+' | cut -c 7-)"
 		if ! min_version_is_satisfied "$libdw_min_version_if_clang" "$libdw_version"; then
 			eprintf "error - libdw version too old for use with clang: %s\n" "$libdw_version"
 			eprintf "Please install libdw from elfutils version %s or greater\n" "$libdw_min_version_if_clang"
 			eprintf "See: https://sourceware.org/elfutils/\n"
 			return 1
 		fi
 	fi

 	if [ ! -d "arch/${ARCH}" ]; then
 		eprintf 'error - ARCH "%s" is not a subdirectory under arch/\n' "$ARCH"
 		eprintf "Please set ARCH to one of:\n%s\n" "$(find arch -maxdepth 1 -mindepth 1 -type d -printf '%f ' | fmt)"
 		return 1
 	fi

 	if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
 		eprintf "error - this script requires the kernel tree to be initialized with Git\n"
 		return 1
 	fi

 	if ! git rev-parse --verify "$past_ref" > /dev/null 2>&1; then
 		printf 'error - invalid git reference "%s"\n' "$past_ref"
 		return 1
 	fi

 	if [ -n "$base_ref" ]; then
 		if ! git merge-base --is-ancestor "$past_ref" "$base_ref" > /dev/null 2>&1; then
 			printf 'error - "%s" is not an ancestor of base ref "%s"\n' "$past_ref" "$base_ref"
 			return 1
 		fi
 		if [ "$(git rev-parse "$base_ref")" = "$(git rev-parse "$past_ref")" ]; then
 			printf 'error - "%s" and "%s" are the same reference\n' "$past_ref" "$base_ref"
 			return 1
 		fi
 	fi
 }

 run() {
 	local base_ref="$1"
 	local past_ref="$2"
 	local abi_error_log="$3"
 	shift 3

 	if [ -z "$KERNEL_SRC" ]; then
 		KERNEL_SRC="$(realpath "$(dirname "$0")"/..)"
 	fi

 	cd "$KERNEL_SRC"

 	if [ -z "$base_ref" ] && ! tree_is_dirty; then
 		base_ref=HEAD
 	fi

 	if [ -z "$past_ref" ]; then
 		if [ -n "$base_ref" ]; then
 			past_ref="${base_ref}^1"
 		else
 			past_ref=HEAD
 		fi
 	fi

 	if ! check_deps; then
 		exit "$FAIL_PREREQ"
 	fi

 	TMP_DIR=$(mktemp -d)
 	readonly TMP_DIR
 	trap 'rm -rf "$TMP_DIR"' EXIT

 	readonly INCOMPAT_LIST="${TMP_DIR}/incompat_list.txt"
 	touch "$INCOMPAT_LIST"

 	readonly SUPPRESSIONS="${TMP_DIR}/suppressions.txt"
 	gen_suppressions > "$SUPPRESSIONS"

 	# Run make install_headers for both refs
 	install_headers "$base_ref" "$past_ref"

 	# Check for any differences in the installed header trees
 	if diff -r -q "$(get_header_tree "$base_ref")" "$(get_header_tree "$past_ref")" > /dev/null 2>&1; then
 		printf "No changes to UAPI headers were applied between %s and %s\n" "$past_ref" "${base_ref:-dirty tree}"
 		exit "$SUCCESS"
 	fi

 	if ! check_uapi_files "$base_ref" "$past_ref" "$abi_error_log"; then
 		exit "$FAIL_ABI"
 	fi
 }

 main() {
 	MAX_THREADS=$(nproc)
 	VERBOSE="false"
 	IGNORE_AMBIGUOUS_CHANGES="false"
 	quiet="false"
 	local base_ref=""
 	while getopts "hb:p:j:l:iqv" opt; do
 		case $opt in
 		h)
 			print_usage
 			exit "$SUCCESS"
 			;;
 		b)
 			base_ref="$OPTARG"
 			;;
 		p)
 			past_ref="$OPTARG"
 			;;
 		j)
 			MAX_THREADS="$OPTARG"
 			;;
 		l)
 			abi_error_log="$OPTARG"
 			;;
 		i)
 			IGNORE_AMBIGUOUS_CHANGES="true"
 			;;
 		q)
 			quiet="true"
 			VERBOSE="false"
 			;;
 		v)
 			VERBOSE="true"
 			quiet="false"
 			;;
 		*)
 			exit "$FAIL_PREREQ"
 		esac
 	done

 	if [ "$quiet" = "true" ]; then
 		exec > /dev/null 2>&1
 	fi

 	run "$base_ref" "$past_ref" "$abi_error_log" "$@"
 }

 main "$@"
	#!/bin/bash
	# SPDX-License-Identifier: GPL-2.0-only
	# Script to check commits for UAPI backwards compatibility

	set -o errexit
	set -o pipefail

	print_usage() {
	name=$(basename "$0")
	cat << EOF
	$name - check for UAPI header stability across Git commits

	By default, the script will check to make sure the latest commit (or current
	dirty changes) did not introduce ABI changes when compared to HEAD^1. You can
	check against additional commit ranges with the -b and -p options.

	The script will not check UAPI headers for architectures other than the one
	defined in ARCH.

	Usage: $name [-b BASE_REF] [-p PAST_REF] [-j N] [-l ERROR_LOG] [-i] [-q] [-v]

	Options:
	-b BASE_REF Base git reference to use for comparison. If unspecified or empty,
	will use any dirty changes in tree to UAPI files. If there are no
	dirty changes, HEAD will be used.
	-p PAST_REF Compare BASE_REF to PAST_REF (e.g. -p v6.1). If unspecified or empty,
	will use BASE_REF^1. Must be an ancestor of BASE_REF. Only headers
	that exist on PAST_REF will be checked for compatibility.
	-j JOBS Number of checks to run in parallel (default: number of CPU cores).
	-l ERROR_LOG Write error log to file (default: no error log is generated).
	-i Ignore ambiguous changes that may or may not break UAPI compatibility.
	-q Quiet operation.
	-v Verbose operation (print more information about each header being checked).

	Environmental args:
	ABIDIFF Custom path to abidiff binary
	CC C compiler (default is "gcc")
	ARCH Target architecture for the UAPI check (default is host arch)

	Exit codes:
	$SUCCESS) Success
	$FAIL_ABI) ABI difference detected
	$FAIL_PREREQ) Prerequisite not met
	EOF
	}

	readonly SUCCESS=0
	readonly FAIL_ABI=1
	readonly FAIL_PREREQ=2

	# Print to stderr
	eprintf() {
	# shellcheck disable=SC2059
	printf "$@" >&2
	}

	# Expand an array with a specific character (similar to Python string.join())
	join() {
	local IFS="$1"
	shift
	printf "%s" "$*"
	}

	# Create abidiff suppressions
	gen_suppressions() {
	# Common enum variant names which we don't want to worry about
	# being shifted when new variants are added.
	local -a enum_regex=(
	".*_AFTER_LAST$"
	".*_CNT$"
	".*_COUNT$"
	".*_END$"
	".*_LAST$"
	".*_MASK$"
	".*_MAX$"
	".*_MAX_BIT$"
	".*_MAX_BPF_ATTACH_TYPE$"
	".*_MAX_ID$"
	".*_MAX_SHIFT$"
	".*_NBITS$"
	".*_NETDEV_NUMHOOKS$"
	".*_NFT_META_IIFTYPE$"
	".*_NL80211_ATTR$"
	".*_NLDEV_NUM_OPS$"
	".*_NUM$"
	".*_NUM_ELEMS$"
	".*_NUM_IRQS$"
	".*_SIZE$"
	".*_TLSMAX$"
	"^MAX_.*"
	"^NUM_.*"
	)

	# Common padding field names which can be expanded into
	# without worrying about users.
	local -a padding_regex=(
	".*end$"
	".*pad$"
	".*pad[0-9]?$"
	".*pad_[0-9]?$"
	".*padding$"
	".*padding[0-9]?$"
	".*padding_[0-9]?$"
	".*res$"
	".*resv$"
	".*resv[0-9]?$"
	".*resv_[0-9]?$"
	".*reserved$"
	".*reserved[0-9]?$"
	".*reserved_[0-9]?$"
	".*rsvd[0-9]?$"
	".*unused$"
	)

	cat << EOF
	[suppress_type]
	type_kind = enum
	changed_enumerators_regexp = $(join , "${enum_regex[@]}")
	EOF

	for p in "${padding_regex[@]}"; do
	cat << EOF
	[suppress_type]
	type_kind = struct
	has_data_member_inserted_at = offset_of_first_data_member_regexp(${p})
	EOF
	done

	if [ "$IGNORE_AMBIGUOUS_CHANGES" = "true" ]; then
	cat << EOF
	[suppress_type]
	type_kind = struct
	has_data_member_inserted_at = end
	has_size_change = yes
	EOF
	fi
	}

	# Check if git tree is dirty
	tree_is_dirty() {
	! git diff --quiet
	}

	# Get list of files installed in $ref
	get_file_list() {
	local -r ref="$1"
	local -r tree="$(get_header_tree "$ref")"

	# Print all installed headers, filtering out ones that can't be compiled
	find "$tree" -type f -name '*.h' -printf '%P\n' \| grep -v -f "$INCOMPAT_LIST"
	}

	# Add to the list of incompatible headers
	add_to_incompat_list() {
	local -r ref="$1"

	# Start with the usr/include/Makefile to get a list of the headers
	# that don't compile using this method.
	if [ ! -f usr/include/Makefile ]; then
	eprintf "error - no usr/include/Makefile present at %s\n" "$ref"
	eprintf "Note: usr/include/Makefile was added in the v5.3 kernel release\n"
	exit "$FAIL_PREREQ"
	fi
	{
	# shellcheck disable=SC2016
	printf 'all: ; @echo $(no-header-test)\n'
	cat usr/include/Makefile
	} \| SRCARCH="$ARCH" make --always-make -f - \| tr " " "\n" \
	\| grep -v "asm-generic" >> "$INCOMPAT_LIST"

	# The makefile also skips all asm-generic files, but prints "asm-generic/%"
	# which won't work for our grep match. Instead, print something grep will match.
	printf "asm-generic/.*\.h\n" >> "$INCOMPAT_LIST"
	}

	# Compile the simple test app
	do_compile() {
	local -r inc_dir="$1"
	local -r header="$2"
	local -r out="$3"
	printf "int main(void) { return 0; }\n" \| \
	"$CC" -c \
	-o "$out" \
	-x c \
	-O0 \
	-std=c90 \
	-fno-eliminate-unused-debug-types \
	-g \
	"-I${inc_dir}" \
	-include "$header" \
	-
	}

	# Run make headers_install
	run_make_headers_install() {
	local -r ref="$1"
	local -r install_dir="$(get_header_tree "$ref")"
	make -j "$MAX_THREADS" ARCH="$ARCH" INSTALL_HDR_PATH="$install_dir" \
	headers_install > /dev/null
	}

	# Install headers for both git refs
	install_headers() {
	local -r base_ref="$1"
	local -r past_ref="$2"

	for ref in "$base_ref" "$past_ref"; do
	printf "Installing user-facing UAPI headers from %s... " "${ref:-dirty tree}"
	if [ -n "$ref" ]; then
	git archive --format=tar --prefix="${ref}-archive/" "$ref" \
	\| (cd "$TMP_DIR" && tar xf -)
	(
	cd "${TMP_DIR}/${ref}-archive"
	run_make_headers_install "$ref"
	add_to_incompat_list "$ref" "$INCOMPAT_LIST"
	)
	else
	run_make_headers_install "$ref"
	add_to_incompat_list "$ref" "$INCOMPAT_LIST"
	fi
	printf "OK\n"
	done
	sort -u -o "$INCOMPAT_LIST" "$INCOMPAT_LIST"
	sed -i -e '/^$/d' "$INCOMPAT_LIST"
	}

	# Print the path to the headers_install tree for a given ref
	get_header_tree() {
	local -r ref="$1"
	printf "%s" "${TMP_DIR}/${ref}/usr"
	}

	# Check file list for UAPI compatibility
	check_uapi_files() {
	local -r base_ref="$1"
	local -r past_ref="$2"
	local -r abi_error_log="$3"

	local passed=0;
	local failed=0;
	local -a threads=()
	set -o errexit

	printf "Checking changes to UAPI headers between %s and %s...\n" "$past_ref" "${base_ref:-dirty tree}"
	# Loop over all UAPI headers that were installed by $past_ref (if they only exist on $base_ref,
	# there's no way they're broken and no way to compare anyway)
	while read -r file; do
	if [ "${#threads[@]}" -ge "$MAX_THREADS" ]; then
	if wait "${threads[0]}"; then
	passed=$((passed + 1))
	else
	failed=$((failed + 1))
	fi
	threads=("${threads[@]:1}")
	fi

	check_individual_file "$base_ref" "$past_ref" "$file" &
	threads+=("$!")
	done < <(get_file_list "$past_ref")

	for t in "${threads[@]}"; do
	if wait "$t"; then
	passed=$((passed + 1))
	else
	failed=$((failed + 1))
	fi
	done

	if [ -n "$abi_error_log" ]; then
	printf 'Generated by "%s %s" from git ref %s\n\n' \
	"$0" "$*" "$(git rev-parse HEAD)" > "$abi_error_log"
	fi

	while read -r error_file; do
	{
	cat "$error_file"
	printf "\n\n"
	} \| tee -a "${abi_error_log:-/dev/null}" >&2
	done < <(find "$TMP_DIR" -type f -name '*.error' \| sort)

	total="$((passed + failed))"
	if [ "$failed" -gt 0 ]; then
	eprintf "error - %d/%d UAPI headers compatible with %s appear _not_ to be backwards compatible\n" \
	"$failed" "$total" "$ARCH"
	if [ -n "$abi_error_log" ]; then
	eprintf "Failure summary saved to %s\n" "$abi_error_log"
	fi
	else
	printf "All %d UAPI headers compatible with %s appear to be backwards compatible\n" \
	"$total" "$ARCH"
	fi

	return "$failed"
	}

	# Check an individual file for UAPI compatibility
	check_individual_file() {
	local -r base_ref="$1"
	local -r past_ref="$2"
	local -r file="$3"

	local -r base_header="$(get_header_tree "$base_ref")/${file}"
	local -r past_header="$(get_header_tree "$past_ref")/${file}"

	if [ ! -f "$base_header" ]; then
	mkdir -p "$(dirname "$base_header")"
	printf "==== UAPI header %s was removed between %s and %s ====" \
	"$file" "$past_ref" "$base_ref" \
	> "${base_header}.error"
	return 1
	fi

	compare_abi "$file" "$base_header" "$past_header" "$base_ref" "$past_ref"
	}

	# Perform the A/B compilation and compare output ABI
	compare_abi() {
	local -r file="$1"
	local -r base_header="$2"
	local -r past_header="$3"
	local -r base_ref="$4"
	local -r past_ref="$5"
	local -r log="${TMP_DIR}/log/${file}.log"
	local -r error_log="${TMP_DIR}/log/${file}.error"

	mkdir -p "$(dirname "$log")"

	if ! do_compile "$(get_header_tree "$base_ref")/include" "$base_header" "${base_header}.bin" 2> "$log"; then
	{
	warn_str=$(printf "==== Could not compile version of UAPI header %s at %s ====\n" \
	"$file" "$base_ref")
	printf "%s\n" "$warn_str"
	cat "$log"
	printf -- "=%.0s" $(seq 0 ${#warn_str})
	} > "$error_log"
	return 1
	fi

	if ! do_compile "$(get_header_tree "$past_ref")/include" "$past_header" "${past_header}.bin" 2> "$log"; then
	{
	warn_str=$(printf "==== Could not compile version of UAPI header %s at %s ====\n" \
	"$file" "$past_ref")
	printf "%s\n" "$warn_str"
	cat "$log"
	printf -- "=%.0s" $(seq 0 ${#warn_str})
	} > "$error_log"
	return 1
	fi

	local ret=0
	"$ABIDIFF" --non-reachable-types \
	--suppressions "$SUPPRESSIONS" \
	"${past_header}.bin" "${base_header}.bin" > "$log" \|\| ret="$?"
	if [ "$ret" -eq 0 ]; then
	if [ "$VERBOSE" = "true" ]; then
	printf "No ABI differences detected in %s from %s -> %s\n" \
	"$file" "$past_ref" "$base_ref"
	fi
	else
	# Bits in abidiff's return code can be used to determine the type of error
	if [ $((ret & 0x2)) -gt 0 ]; then
	eprintf "error - abidiff did not run properly\n"
	exit 1
	fi

	if [ "$IGNORE_AMBIGUOUS_CHANGES" = "true" ] && [ "$ret" -eq 4 ]; then
	return 0
	fi

	# If the only changes were additions (not modifications to existing APIs), then
	# there's no problem. Ignore these diffs.
	if grep "Unreachable types summary" "$log" \| grep -q "0 removed" &&
	grep "Unreachable types summary" "$log" \| grep -q "0 changed"; then
	return 0
	fi

	{
	warn_str=$(printf "==== ABI differences detected in %s from %s -> %s ====" \
	"$file" "$past_ref" "$base_ref")
	printf "%s\n" "$warn_str"
	sed -e '/summary:/d' -e '/changed type/d' -e '/^$/d' -e 's/^/ /g' "$log"
	printf -- "=%.0s" $(seq 0 ${#warn_str})
	if cmp "$past_header" "$base_header" > /dev/null 2>&1; then
	printf "\n%s did not change between %s and %s...\n" "$file" "$past_ref" "${base_ref:-dirty tree}"
	printf "It's possible a change to one of the headers it includes caused this error:\n"
	grep '^#include' "$base_header"
	printf "\n"
	fi
	} > "$error_log"

	return 1
	fi
	}

	# Check that a minimum software version number is satisfied
	min_version_is_satisfied() {
	local -r min_version="$1"
	local -r version_installed="$2"

	printf "%s\n%s\n" "$min_version" "$version_installed" \
	\| sort -Vc > /dev/null 2>&1
	}

	# Make sure we have the tools we need and the arguments make sense
	check_deps() {
	ABIDIFF="${ABIDIFF:-abidiff}"
	CC="${CC:-gcc}"
	ARCH="${ARCH:-$(uname -m)}"
	if [ "$ARCH" = "x86_64" ]; then
	ARCH="x86"
	fi

	local -r abidiff_min_version="2.4"
	local -r libdw_min_version_if_clang="0.171"

	if ! command -v "$ABIDIFF" > /dev/null 2>&1; then
	eprintf "error - abidiff not found!\n"
	eprintf "Please install abigail-tools version %s or greater\n" "$abidiff_min_version"
	eprintf "See: https://sourceware.org/libabigail/manual/libabigail-overview.html\n"
	return 1
	fi

	local -r abidiff_version="$("$ABIDIFF" --version \| cut -d ' ' -f 2)"
	if ! min_version_is_satisfied "$abidiff_min_version" "$abidiff_version"; then
	eprintf "error - abidiff version too old: %s\n" "$abidiff_version"
	eprintf "Please install abigail-tools version %s or greater\n" "$abidiff_min_version"
	eprintf "See: https://sourceware.org/libabigail/manual/libabigail-overview.html\n"
	return 1
	fi

	if ! command -v "$CC" > /dev/null 2>&1; then
	eprintf 'error - %s not found\n' "$CC"
	return 1
	fi

	if "$CC" --version \| grep -q clang; then
	local -r libdw_version="$(ldconfig -v 2>/dev/null \| grep -v SKIPPED \| grep -m 1 -o 'libdw-[0-9]\+.[0-9]\+' \| cut -c 7-)"
	if ! min_version_is_satisfied "$libdw_min_version_if_clang" "$libdw_version"; then
	eprintf "error - libdw version too old for use with clang: %s\n" "$libdw_version"
	eprintf "Please install libdw from elfutils version %s or greater\n" "$libdw_min_version_if_clang"
	eprintf "See: https://sourceware.org/elfutils/\n"
	return 1
	fi
	fi

	if [ ! -d "arch/${ARCH}" ]; then
	eprintf 'error - ARCH "%s" is not a subdirectory under arch/\n' "$ARCH"
	eprintf "Please set ARCH to one of:\n%s\n" "$(find arch -maxdepth 1 -mindepth 1 -type d -printf '%f ' \| fmt)"
	return 1
	fi

	if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
	eprintf "error - this script requires the kernel tree to be initialized with Git\n"
	return 1
	fi

	if ! git rev-parse --verify "$past_ref" > /dev/null 2>&1; then
	printf 'error - invalid git reference "%s"\n' "$past_ref"
	return 1
	fi

	if [ -n "$base_ref" ]; then
	if ! git merge-base --is-ancestor "$past_ref" "$base_ref" > /dev/null 2>&1; then
	printf 'error - "%s" is not an ancestor of base ref "%s"\n' "$past_ref" "$base_ref"
	return 1
	fi
	if [ "$(git rev-parse "$base_ref")" = "$(git rev-parse "$past_ref")" ]; then
	printf 'error - "%s" and "%s" are the same reference\n' "$past_ref" "$base_ref"
	return 1
	fi
	fi
	}

	run() {
	local base_ref="$1"
	local past_ref="$2"
	local abi_error_log="$3"
	shift 3

	if [ -z "$KERNEL_SRC" ]; then
	KERNEL_SRC="$(realpath "$(dirname "$0")"/..)"
	fi

	cd "$KERNEL_SRC"

	if [ -z "$base_ref" ] && ! tree_is_dirty; then
	base_ref=HEAD
	fi

	if [ -z "$past_ref" ]; then
	if [ -n "$base_ref" ]; then
	past_ref="${base_ref}^1"
	else
	past_ref=HEAD
	fi
	fi

	if ! check_deps; then
	exit "$FAIL_PREREQ"
	fi

	TMP_DIR=$(mktemp -d)
	readonly TMP_DIR
	trap 'rm -rf "$TMP_DIR"' EXIT

	readonly INCOMPAT_LIST="${TMP_DIR}/incompat_list.txt"
	touch "$INCOMPAT_LIST"

	readonly SUPPRESSIONS="${TMP_DIR}/suppressions.txt"
	gen_suppressions > "$SUPPRESSIONS"

	# Run make install_headers for both refs
	install_headers "$base_ref" "$past_ref"

	# Check for any differences in the installed header trees
	if diff -r -q "$(get_header_tree "$base_ref")" "$(get_header_tree "$past_ref")" > /dev/null 2>&1; then
	printf "No changes to UAPI headers were applied between %s and %s\n" "$past_ref" "${base_ref:-dirty tree}"
	exit "$SUCCESS"
	fi

	if ! check_uapi_files "$base_ref" "$past_ref" "$abi_error_log"; then
	exit "$FAIL_ABI"
	fi
	}

	main() {
	MAX_THREADS=$(nproc)
	VERBOSE="false"
	IGNORE_AMBIGUOUS_CHANGES="false"
	quiet="false"
	local base_ref=""
	while getopts "hb:p:j:l:iqv" opt; do
	case $opt in
	h)
	print_usage
	exit "$SUCCESS"
	;;
	b)
	base_ref="$OPTARG"
	;;
	p)
	past_ref="$OPTARG"
	;;
	j)
	MAX_THREADS="$OPTARG"
	;;
	l)
	abi_error_log="$OPTARG"
	;;
	i)
	IGNORE_AMBIGUOUS_CHANGES="true"
	;;
	q)
	quiet="true"
	VERBOSE="false"
	;;
	v)
	VERBOSE="true"
	quiet="false"
	;;
	*)
	exit "$FAIL_PREREQ"
	esac
	done

	if [ "$quiet" = "true" ]; then
	exec > /dev/null 2>&1
	fi

	run "$base_ref" "$past_ref" "$abi_error_log" "$@"
	}

	main "$@"