f93e83b0e3* Sat Dec 13 2025 Justin M. Forbes <jforbes@fedoraproject.org> [6.18.1-0] - Initial setup for stable Fedora releases (Justin M. Forbes) - Reset RHEL_RELEASE for the 6.19 cycle (Justin M. Forbes) - add libasan-static and libubsan as BR for selftests (Thorsten Leemhuis) - add liburing-devel as BR for selftests (Thorsten Leemhuis) - add a few optional BRs for perf (Thorsten Leemhuis) - Linux v6.18.1 Resolves: Signed-off-by: Justin M. Forbes <jforbes@fedoraproject.org>
590 lines
16 KiB
Bash
Executable file
590 lines
16 KiB
Bash
Executable file
#!/bin/bash
|
|
#
|
|
# This script takes the merged config files and processes them through olddefconfig
|
|
# and listnewconfig to ensure kernel configurations are valid and complete.
|
|
#
|
|
# Globally disable suggestion of appending '|| exit' or '|| return' to cd/pushd/popd commands
|
|
# shellcheck disable=SC2164
|
|
|
|
# Exit if this is a test environment
|
|
test -n "$RHTEST" && exit 0
|
|
|
|
# Display usage information and available command line options
|
|
usage()
|
|
{
|
|
# alphabetical order please
|
|
echo "process_configs.sh [ options ] package_name kernel_version"
|
|
echo " -a: report all errors, equivalent to [-c -n -w -i]"
|
|
echo " -c: error on mismatched config options"
|
|
echo " -i: ignore any errors, but print them"
|
|
echo " -m: specify make options (e.g., -m CC=clang, -m LLVM=1)"
|
|
echo " -M: commit mismatched configs to pending directory"
|
|
echo " -n: error on unset config options"
|
|
echo " -t: test run, do not overwrite original config"
|
|
echo " -w: error on misconfigured config options"
|
|
echo " -z: commit new configs to pending directory"
|
|
echo ""
|
|
echo " A special CONFIG file tag, process_configs_known_broken can be added as a"
|
|
echo " comment to any CONFIG file. This tag indicates that there is no way to "
|
|
echo " fix a CONFIG's entry. This tag should only be used in extreme cases"
|
|
echo " and is not to be used as a workaround to solve CONFIG problems."
|
|
exit 1
|
|
}
|
|
|
|
die()
|
|
{
|
|
echo "$1"
|
|
exit 1
|
|
}
|
|
|
|
# Determine the correct cross-compiler prefix based on compiler type
|
|
# For clang builds, return the architecture directly
|
|
# For GCC builds, use the dummy-tools directory
|
|
get_cross_compile()
|
|
{
|
|
arch=$1
|
|
if [[ "$CC_IS_CLANG" -eq 1 ]]; then
|
|
echo "$arch"
|
|
else
|
|
echo "scripts/dummy-tools/"
|
|
fi
|
|
}
|
|
|
|
# Find the top-level kernel source directory
|
|
# (identified by MAINTAINERS file and drivers directory)
|
|
switch_to_toplevel()
|
|
{
|
|
path="$(pwd)"
|
|
while test -n "$path"
|
|
do
|
|
test -e "$path"/MAINTAINERS && \
|
|
test -d "$path"/drivers && \
|
|
break
|
|
|
|
path=$(dirname "$path")
|
|
done
|
|
|
|
test -n "$path" || die "Can't find toplevel"
|
|
echo "$path"
|
|
}
|
|
|
|
# Determine the correct config path based on architecture and variant
|
|
# This function maps arch/variant combinations to the proper pending directory
|
|
determine_config_path()
|
|
{
|
|
local arch="$1"
|
|
local variant="$2"
|
|
local config_path=""
|
|
|
|
# Identify the variant - they have their own top-level directories
|
|
if [[ "$variant" == *"rt"* ]]; then
|
|
# RT variant - goes under rt/
|
|
if [[ "$variant" == *"debug"* ]]; then
|
|
config_path="rt/debug"
|
|
else
|
|
config_path="rt/generic"
|
|
fi
|
|
elif [[ "$variant" == *"automotive"* ]]; then
|
|
# Automotive variant - goes under automotive/
|
|
if [[ "$variant" == *"debug"* ]]; then
|
|
config_path="automotive/debug"
|
|
else
|
|
config_path="automotive/generic"
|
|
fi
|
|
else
|
|
# Stock kernel - goes under top-level debug or generic
|
|
if [[ "$variant" == *"debug"* ]]; then
|
|
config_path="debug"
|
|
else
|
|
config_path="generic"
|
|
fi
|
|
fi
|
|
|
|
# Add architecture-specific subdirectories
|
|
case "$arch" in
|
|
arm64)
|
|
config_path="$config_path/arm/aarch64"
|
|
;;
|
|
powerpc)
|
|
config_path="$config_path/powerpc"
|
|
;;
|
|
riscv)
|
|
config_path="$config_path/riscv/riscv64"
|
|
;;
|
|
s390)
|
|
if [[ "$variant" == *"zfcpdump"* ]]; then
|
|
config_path="$config_path/s390x/zfcpdump"
|
|
else
|
|
config_path="$config_path/s390x"
|
|
fi
|
|
;;
|
|
x86_64)
|
|
config_path="$config_path/x86"
|
|
;;
|
|
*)
|
|
# For unknown architectures, don't add arch subdirectory
|
|
;;
|
|
esac
|
|
|
|
echo "$config_path"
|
|
}
|
|
|
|
# Parse mismatched configs found during processing and create
|
|
# individual CONFIG files in the pending directory for each
|
|
parse_mismatched_configs()
|
|
{
|
|
local tmpdir
|
|
local count=$1 # Counter for unique filenames
|
|
local arch=$2
|
|
local variant=$3
|
|
|
|
tmpdir=$(mktemp -d)
|
|
|
|
# Parse the mismatches file and create individual CONFIG files
|
|
tail -n +2 .mismatches"${count}" | while read -r LINE
|
|
do
|
|
if echo "$LINE" | grep -q "Found # .* is not set, after generation"; then
|
|
# Handle case where we found "# CONFIG_FOO is not set" after generation
|
|
config_name="${LINE#*Found # }"
|
|
config_name="${config_name% is not set, after generation*}"
|
|
if [ -n "$config_name" ]; then
|
|
echo "# Mismatch found in $arch $variant config" > "$tmpdir/$config_name"
|
|
echo "# $config_name is not set" >> "$tmpdir/$config_name"
|
|
fi
|
|
elif echo "$LINE" | grep -q "Found .* after generation"; then
|
|
# Handle case where we found "CONFIG_FOO=value" after generation
|
|
config_name="${LINE#*Found }"
|
|
config_name="${config_name% after generation*}"
|
|
config_name="${config_name%=*}"
|
|
config_value="${LINE#*Found }"
|
|
config_value="${config_value#*=}"
|
|
config_value="${config_value% after generation*}"
|
|
if [ -n "$config_name" ] && [ -n "$config_value" ]; then
|
|
echo "# Mismatch found in $arch $variant config" > "$tmpdir/$config_name"
|
|
echo "$config_name=$config_value" >> "$tmpdir/$config_name"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Copy the CONFIG files to the pending directory
|
|
config_path=$(determine_config_path "$arch" "$variant")
|
|
mkdir -p "$SCRIPT_DIR/pending-$FLAVOR/$config_path/"
|
|
for f in "$tmpdir"/*; do
|
|
[[ -e "$f" ]] || break
|
|
cp "$f" "$SCRIPT_DIR/pending-$FLAVOR/$config_path/"
|
|
done
|
|
|
|
rm -rf "$tmpdir"
|
|
}
|
|
|
|
# Check for configuration mismatches between the original and generated configs
|
|
checkoptions()
|
|
{
|
|
cfg=$1 # Original config file
|
|
cfgtmp=$2 # Generated config file
|
|
count=$3 # Counter for unique filenames
|
|
variant=$4 # Config variant (e.g., debug, rt)
|
|
|
|
# This awk script compares configuration files for mismatches
|
|
/usr/bin/awk '
|
|
|
|
/is not set/ {
|
|
split ($0, a, "#");
|
|
split(a[2], b);
|
|
if (NR==FNR) {
|
|
configs[b[1]]="is not set";
|
|
} else {
|
|
if (configs[b[1]] != "" && configs[b[1]] != "is not set")
|
|
print "Found # "b[1] " is not set, after generation, had " b[1] " " configs[b[1]] " in Source tree";
|
|
}
|
|
}
|
|
|
|
/=/ {
|
|
split ($0, a, "=");
|
|
if (NR==FNR) {
|
|
configs[a[1]]=a[2];
|
|
} else {
|
|
if (configs[a[1]] != "" && configs[a[1]] != a[2])
|
|
print "Found "a[1]"="a[2]" after generation, had " a[1]"="configs[a[1]]" in Source tree";
|
|
}
|
|
}
|
|
' "$cfg" "$cfgtmp" > .mismatches"${count}"
|
|
|
|
checkoptions_error=false
|
|
if test -s .mismatches"${count}"
|
|
then
|
|
while read -r LINE
|
|
do
|
|
if find "${REDHAT}"/configs -name "$(echo "$LINE" | awk -F "=" ' { print $1 } ' | awk ' { print $2 }')" -print0 | xargs -0 grep ^ | grep -q "process_configs_known_broken"; then
|
|
# This is a known broken config.
|
|
# See script help warning.
|
|
checkoptions_error=false
|
|
else
|
|
checkoptions_error=true
|
|
break
|
|
fi
|
|
done < .mismatches"${count}"
|
|
|
|
! $checkoptions_error && return
|
|
|
|
sed -i "1s/^/Error: Mismatches found in configuration files for ${arch} ${variant}\n/" .mismatches"${count}"
|
|
|
|
# Add mismatched configs to the pending directory
|
|
if test -n "$COMMITMISMATCHES"; then
|
|
parse_mismatched_configs "$count" "$arch" "$variant"
|
|
fi
|
|
else
|
|
rm -f .mismatches"${count}"
|
|
fi
|
|
}
|
|
|
|
# Parse the output of 'make listnewconfig' and 'make helpnewconfig'
|
|
# to create properly formatted configuration files for new configs
|
|
parsenewconfigs()
|
|
{
|
|
tmpdir=$(mktemp -d)
|
|
|
|
# This awk script reads the output of make listnewconfig
|
|
# and puts it into CONFIG_FOO files. Using the output of
|
|
# listnewconfig is much easier to ensure we get the default
|
|
# output.
|
|
/usr/bin/awk -v BASE="$tmpdir" '
|
|
/is not set/ {
|
|
split ($0, a, "#");
|
|
split(a[2], b);
|
|
OUT_FILE=BASE"/"b[1];
|
|
print $0 >> OUT_FILE;
|
|
}
|
|
|
|
/=/ {
|
|
split ($0, a, "=");
|
|
OUT_FILE=BASE"/"a[1];
|
|
if (a[2] == "n")
|
|
print "# " a[1] " is not set" >> OUT_FILE;
|
|
else
|
|
print $0 >> OUT_FILE;
|
|
}
|
|
|
|
' .newoptions
|
|
|
|
# This awk script parses the output of helpnewconfig.
|
|
# Each option is separated between ----- markers
|
|
# The goal is to put all the help text as a comment in
|
|
# each CONFIG_FOO file. Because of how awk works
|
|
# there's a lot of moving files around and catting to
|
|
# get what we need.
|
|
/usr/bin/awk -v BASE="$tmpdir" '
|
|
BEGIN { inpatch=0;
|
|
outfile="none";
|
|
symbol="none";
|
|
commit=""; }
|
|
/^Symbol: .*$/ {
|
|
split($0, a, " ");
|
|
symbol="CONFIG_"a[2];
|
|
outfile=BASE "/fake_"symbol
|
|
print "# ~~~" >> outfile;
|
|
}
|
|
/-----/ {
|
|
if (inpatch == 0) {
|
|
inpatch = 1;
|
|
}
|
|
else {
|
|
print "# ~~~" >> outfile;
|
|
if (symbol != "none") {
|
|
print "# Commit: "commit >> outfile
|
|
system("cat " outfile " " BASE "/" symbol " > " BASE "/tmpf");
|
|
system("mv " BASE "/tmpf " BASE "/" symbol);
|
|
symbol="none"
|
|
commit=""
|
|
}
|
|
outfile="none"
|
|
inpatch = 0;
|
|
}
|
|
}
|
|
!/-----/ {
|
|
if (inpatch == 1 && outfile != "none") {
|
|
print "# "$0 >> outfile;
|
|
}
|
|
}
|
|
/^Defined at .*$/ {
|
|
split($0, x, " ");
|
|
filenum=x[3];
|
|
split(filenum, x, ":");
|
|
file=x[1]
|
|
line=x[2]
|
|
cmd="git blame -L " line "," line " " file " | cut -d \" \" -f1 | xargs git log --pretty=format:\"%C(auto)%h %C(cyan)('%s')\" -1"
|
|
cmd | getline commit
|
|
}
|
|
|
|
|
|
' .helpnewconfig
|
|
|
|
pushd "$tmpdir" &> /dev/null
|
|
rm fake_*
|
|
popd &> /dev/null
|
|
for f in "$tmpdir"/*; do
|
|
[[ -e "$f" ]] || break
|
|
cp "$f" "$SCRIPT_DIR/pending-$FLAVOR/generic/"
|
|
done
|
|
|
|
rm -rf "$tmpdir"
|
|
}
|
|
|
|
# Commit any mismatched configs that were saved to the pending directory
|
|
commit_mismatched_configs()
|
|
{
|
|
# assume we are in $source_tree/configs, need to get to top level
|
|
pushd "$(switch_to_toplevel)" &>/dev/null
|
|
|
|
# Check if there are any modified or untracked mismatched configs to commit
|
|
if git status --porcelain "$SCRIPT_DIR/pending-$FLAVOR/" | grep -q .; then
|
|
echo "Committing mismatched configuration files..."
|
|
git add "$SCRIPT_DIR/pending-$FLAVOR"
|
|
git commit -m "[redhat] AUTOMATIC: Mismatched $FLAVOR configs"
|
|
echo "Mismatched configs committed to pending-$FLAVOR directory"
|
|
else
|
|
echo "No mismatched configs found to commit"
|
|
fi
|
|
|
|
popd &>/dev/null
|
|
}
|
|
|
|
# Processes all config files, finds new/unset configs, and commits them
|
|
function commit_new_configs()
|
|
{
|
|
# assume we are in $source_tree/configs, need to get to top level
|
|
pushd "$(switch_to_toplevel)" &>/dev/null
|
|
|
|
for cfg in "$SCRIPT_DIR/${SPECPACKAGE_NAME}${KVERREL}"*.config
|
|
do
|
|
arch=$(head -1 "$cfg" | cut -b 3-)
|
|
cfgtmp="${cfg}.tmp"
|
|
cfgorig="${cfg}.orig"
|
|
cat "$cfg" > "$cfgorig"
|
|
|
|
if [ "$arch" = "EMPTY" ]
|
|
then
|
|
# This arch is intentionally left blank
|
|
continue
|
|
fi
|
|
echo -n "Checking for new configs in $cfg ... "
|
|
|
|
# shellcheck disable=SC2086
|
|
make ${MAKEOPTS} ARCH="$arch" CROSS_COMPILE="$(get_cross_compile "$arch")" KCONFIG_CONFIG="$cfgorig" listnewconfig >& .listnewconfig
|
|
grep -E 'CONFIG_' .listnewconfig > .newoptions
|
|
if test -s .newoptions
|
|
then
|
|
# shellcheck disable=SC2086
|
|
make ${MAKEOPTS} ARCH="$arch" CROSS_COMPILE="$(get_cross_compile "$arch")" KCONFIG_CONFIG="$cfgorig" helpnewconfig >& .helpnewconfig
|
|
parsenewconfigs
|
|
fi
|
|
rm .newoptions
|
|
echo "done"
|
|
done
|
|
|
|
# Commit the new configuration files to git
|
|
git add "$SCRIPT_DIR/pending-$FLAVOR"
|
|
# DO NOT CHANGE THIS MESSAGE! gen_config_patches.sh looks for this commit message.
|
|
git commit -m "[redhat] AUTOMATIC: New configs"
|
|
}
|
|
|
|
# Process a single configuration file
|
|
function process_config()
|
|
{
|
|
local cfg
|
|
local arch
|
|
local cfgtmp
|
|
local cfgorig
|
|
local count
|
|
local variant
|
|
|
|
cfg=$1
|
|
count=$2
|
|
|
|
arch=$(head -1 "$cfg" | cut -b 3-)
|
|
|
|
if [ "$arch" = "EMPTY" ]
|
|
then
|
|
# This arch is intentionally left blank
|
|
return
|
|
fi
|
|
|
|
variant=$(basename "$cfg" | cut -d"-" -f3- | cut -d"." -f1)
|
|
|
|
cfgtmp="${cfg}.tmp"
|
|
cfgorig="${cfg}.orig"
|
|
cat "$cfg" > "$cfgorig"
|
|
|
|
echo "Processing $cfg ... "
|
|
|
|
# shellcheck disable=SC2086
|
|
make ${MAKEOPTS} ARCH="$arch" CROSS_COMPILE="$(get_cross_compile "$arch")" KCONFIG_CONFIG="$cfgorig" listnewconfig >& .listnewconfig"${count}"
|
|
grep -E 'CONFIG_' .listnewconfig"${count}" > .newoptions"${count}"
|
|
if test -n "$NEWOPTIONS" && test -s .newoptions"${count}"
|
|
then
|
|
echo "Found unset config items in ${arch} ${variant}, please set them to an appropriate value" >> .errors"${count}"
|
|
cat .newoptions"${count}" >> .errors"${count}"
|
|
rm .newoptions"${count}"
|
|
RETURNCODE=1
|
|
fi
|
|
rm -f .newoptions"${count}"
|
|
|
|
grep -E 'config.*warning' .listnewconfig"${count}" > .warnings"${count}"
|
|
if test -n "$CHECKWARNINGS" && test -s .warnings"${count}"
|
|
then
|
|
echo "Found misconfigured config items in ${arch} ${variant}, please set them to an appropriate value" >> .errors"${count}"
|
|
cat .warnings"${count}" >> .errors"${count}"
|
|
fi
|
|
rm .warnings"${count}"
|
|
|
|
rm .listnewconfig"${count}"
|
|
|
|
# shellcheck disable=SC2086
|
|
make ${MAKEOPTS} ARCH="$arch" CROSS_COMPILE="$(get_cross_compile "$arch")" KCONFIG_CONFIG="$cfgorig" olddefconfig > /dev/null || exit 1
|
|
echo "# $arch" > "$cfgtmp"
|
|
cat "$cfgorig" >> "$cfgtmp"
|
|
if test -n "$CHECKOPTIONS"
|
|
then
|
|
checkoptions "$cfg" "$cfgtmp" "$count" "$variant"
|
|
fi
|
|
# if test run, don't overwrite original
|
|
if test -n "$TESTRUN"
|
|
then
|
|
rm -f "$cfgtmp"
|
|
else
|
|
mv "$cfgtmp" "$cfg"
|
|
fi
|
|
rm -f "$cfgorig"
|
|
echo "Processing $cfg complete"
|
|
}
|
|
|
|
# Process all configuration files
|
|
# Handles parallel processing and error reporting
|
|
function process_configs()
|
|
{
|
|
# assume we are in $source_tree/configs, need to get to top level
|
|
pushd "$(switch_to_toplevel)" &>/dev/null
|
|
|
|
count=0
|
|
for cfg in "$SCRIPT_DIR/${SPECPACKAGE_NAME}${KVERREL}"*.config
|
|
do
|
|
if [ "$count" -eq 0 ]; then
|
|
# do the first one by itself so that tools are built
|
|
process_config "$cfg" "$count"
|
|
fi
|
|
process_config "$cfg" "$count" &
|
|
# shellcheck disable=SC2004
|
|
waitpids[${count}]=$!
|
|
((count++))
|
|
while [ "$(jobs | grep -c Running)" -ge "$RHJOBS" ]; do :; done
|
|
done
|
|
# shellcheck disable=SC2048
|
|
for pid in ${waitpids[*]}; do
|
|
wait "${pid}"
|
|
done
|
|
|
|
rm "$SCRIPT_DIR"/*.config*.old
|
|
|
|
if ls .errors* 1> /dev/null 2>&1; then
|
|
RETURNCODE=1
|
|
cat .errors*
|
|
rm .errors* -f
|
|
fi
|
|
|
|
# Commit any mismatched configs found during processing
|
|
if [ $RETURNCODE -eq 0 ] && test -n "$COMMITMISMATCHES"; then
|
|
rm .mismatches* -f
|
|
commit_mismatched_configs
|
|
# Otherwise, display any mismatched configs
|
|
elif ls .mismatches* 1> /dev/null 2>&1; then
|
|
RETURNCODE=1
|
|
cat .mismatches*
|
|
rm .mismatches* -f
|
|
fi
|
|
|
|
popd > /dev/null
|
|
|
|
[ $RETURNCODE -eq 0 ] && echo "Processed config files are in $SCRIPT_DIR"
|
|
}
|
|
|
|
CHECKOPTIONS=""
|
|
IGNOREERRORS=""
|
|
NEWOPTIONS=""
|
|
TESTRUN=""
|
|
CHECKWARNINGS=""
|
|
MAKEOPTS=""
|
|
CC_IS_CLANG=0
|
|
COMMITMISMATCHES=""
|
|
|
|
RETURNCODE=0
|
|
|
|
while [[ $# -gt 0 ]]
|
|
do
|
|
key="$1"
|
|
case $key in
|
|
-a)
|
|
# Enable all error checking options
|
|
CHECKOPTIONS="x"
|
|
IGNOREERRORS="x"
|
|
NEWOPTIONS="x"
|
|
CHECKWARNINGS="x"
|
|
;;
|
|
-c)
|
|
CHECKOPTIONS="x"
|
|
;;
|
|
-h)
|
|
usage
|
|
;;
|
|
-i)
|
|
IGNOREERRORS="x"
|
|
;;
|
|
-n)
|
|
NEWOPTIONS="x"
|
|
;;
|
|
-t)
|
|
TESTRUN="x"
|
|
;;
|
|
-w)
|
|
CHECKWARNINGS="x"
|
|
;;
|
|
-z)
|
|
COMMITNEWCONFIGS="x"
|
|
;;
|
|
-m)
|
|
shift
|
|
# Handle clang compiler options
|
|
if [ "$1" = "CC=clang" ] || [ "$1" = "LLVM=1" ]; then
|
|
CC_IS_CLANG=1
|
|
fi
|
|
MAKEOPTS="$MAKEOPTS $1"
|
|
;;
|
|
-M)
|
|
COMMITMISMATCHES="x"
|
|
CHECKOPTIONS="x"
|
|
;;
|
|
*)
|
|
break;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
KVERREL="$(test -n "$1" && echo "-$1" || echo "")"
|
|
FLAVOR="$(test -n "$2" && echo "$2" || echo "rhel")"
|
|
# shellcheck disable=SC2015
|
|
SCRIPT=$(readlink -f "$0")
|
|
SCRIPT_DIR=$(dirname "$SCRIPT")
|
|
|
|
# to handle this script being a symlink
|
|
cd "$SCRIPT_DIR"
|
|
|
|
if test -n "$COMMITNEWCONFIGS"; then
|
|
commit_new_configs
|
|
else
|
|
process_configs
|
|
fi
|
|
|
|
if test -n "$IGNOREERRORS"; then
|
|
exit 0
|
|
else
|
|
exit $RETURNCODE
|
|
fi
|