Quelle check-uapi.sh Sprache: Shell

#!/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 "$@"

quality95%

¤ Dauer der Verarbeitung: 0.20 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.