#! /bin/bash

#############################################################################

# Copyright (c) 2003-2005,2007-2009 Novell, Inc.

# All Rights Reserved.

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of version 2 of the GNU General Public License as

# published by the Free Software Foundation.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, contact Novell, Inc.

#

# To contact Novell about this file by physical or electronic mail,

# you may find current contact information at www.novell.com

#############################################################################

[ -f $(dirname $0)/../rpm/config.sh ] || exit 0

source $(dirname $0)/../rpm/config.sh

source $(dirname $0)/wd-functions.sh

set -o pipefail

fuzz="-F0"

usage() {

cat <<END

SYNOPSIS: $0 [-qv] [--symbol=...] [--dir=...]

[--fast] [--rapid] [stop-before-patch-name] [--vanilla] [--fuzz=NUM]

[--patch-dir=PATH] [--build-dir=PATH] [--config=ARCH-FLAVOR [--kabi]]

[--ctags] [--cscope] [--etags] [--dry-run]

The --build-dir option supports internal shell aliases, like ~, and variable

expansion when the variables are properly escaped. Environment variables

and the following list of internal variables are permitted:

\$PATCH_DIR: The expanded source tree

\$SRCVERSION: The current linux source tarball version

\$TAG: The current tag or branch of this repo

\$EXT: A string expanded from current \$EXTRA_SYMBOLS

With --config=ARCH-FLAVOR, these have values. Otherwise they are empty.

\$CONFIG: The current ARCH-FLAVOR.

\$CONFIG_ARCH: The current ARCH.

\$CONFIG_FLAVOR: The current FLAVOR.

The --no-quilt option will still create quilt-style backups for each

file that is modified but the backups will be removed if the patch

is successful. This can be fast because the new files may be created

and removed before writeback occurs so they only exist in memory. A

failed patch will be rolled back and the caller will be able to diagnose it.

The --fast option will concatenate all the patches to be applied and

call patch just once. This is even faster than --no-quilt but if any

of the component patches fail to apply the tree will not be rolled

back.

The --rapid option will use rapidquilt to apply patches.

The --dry-run option only works with --fast and --rapid.

The --signing-key option specifies a pathname for a key to be used for

module signing and for signing the kernel for use with UEFI Secure Boot.

When used with stop-before-patch-name, both --fast and --no-quilt

will set up a quilt environment for the remaining patches.

END

exit 1

}

apply_rapid_patches() {

printf "%s\n" ${PATCHES_BEFORE[@]} >> $PATCH_DIR/series

rapidquilt push -a -d $PATCH_DIR -p $PWD $fuzz $DRY_RUN

status=$?

}

apply_fast_patches() {

echo "[ Fast-applying ${#PATCHES_BEFORE[@]} patches. ${#PATCHES_AFTER[@]} remain. ]"

LAST_LOG=$(echo "${PATCHES_BEFORE[@]}" | xargs cat | \

patch -d $PATCH_DIR -p1 -E $fuzz --force --no-backup-if-mismatch \

-s $DRY_RUN 2>&1)

STATUS=$?

if [ $STATUS -ne 0 ]; then

echo "$LAST_LOG" >> $PATCH_LOG

[ -n "$QUIET" ] && echo "$LAST_LOG"

echo "All-in-one patch failed (not rolled back)."

echo "Logfile: $PATCH_LOG"

status=1

fi

}

# Patch kernel normally

apply_one_patch() {

echo "[ $PATCH ]"

echo "[ $PATCH ]" >> $PATCH_LOG

backup_dir=$PATCH_DIR/.pc/$PATCH

LAST_LOG=$(patch -d $PATCH_DIR --backup --prefix=$backup_dir/ -p1 -E $fuzz \

--no-backup-if-mismatch --force < $PATCH 2>&1)

STATUS=$?

if [ $STATUS -ne 0 ]; then

restore_files $backup_dir $PATCH_DIR

# Backup directory is no longer needed

rm -rf $backup_dir

else

if $QUILT; then

echo "$PATCH" >> $PATCH_DIR/.pc/applied-patches

fi

fi

if ! $QUILT; then

rm -rf $PATCH_DIR/.pc/

fi

echo "$LAST_LOG" >> $PATCH_LOG

[ -z "$QUIET" ] && echo "$LAST_LOG"

if [ $STATUS -ne 0 ]; then

[ -n "$QUIET" ] && echo "$LAST_LOG"

echo "Patch $PATCH failed (rolled back)."

echo "Logfile: $PATCH_LOG"

status=1

return 1

else

echo "$SERIES_PFX$PATCH" >> $PATCH_DIR/series

fi

return 0

}

apply_patches() {

for ((n=0; n<${#PATCHES_BEFORE[@]}; n++)); do

PATCH=${PATCHES_BEFORE[n]}

if [ ! -r "$PATCH" ]; then

echo "Patch $PATCH not found."

status=1

break

fi

apply_one_patch || break

done

}

apply_rest_patches() {

STEP_BY_STEP=1

echo "Stopping before ${PATCHES[0]}"

for ((n=0; n<${#PATCHES[@]}; n++)); do

PATCH=${PATCHES[n]}

if [ ! -r "$PATCH" ]; then

echo "Patch $PATCH not found."

status=1

break

fi

if [ -n "$STEP_BY_STEP" ]; then

while true; do

echo -n "Continue ([y]es/[n]o/yes to [a]ll)?"

read YESNO

case $YESNO in

([yYjJsS])

break

;;

([nN])

break 2 # break out of outer loop

;;

([aA])

unset STEP_BY_STEP

break

;;

esac

done

fi

apply_one_patch || break

done

}

# Allow to pass in default arguments via SEQUENCE_PATCH_ARGS.

set -- $SEQUENCE_PATCH_ARGS "$@"

options="$(getopt -o qvd:F: --long quilt,no-quilt,symbol:,dir:,combine,fast,rapid,vanilla,fuzz:,patch-dir:,build-dir:,config:,kabi,ctags,cscope,etags,dry-run,signing-key: -- "$@")"

if [ $? -ne 0 ]

then

usage

fi

eval set -- "$options"

QUIET=1

EXTRA_SYMBOLS=

QUILT=true

FAST=

RAPID=

VANILLA=false

SP_BUILD_DIR=

CONFIG=

CONFIG_ARCH=

CONFIG_FLAVOR=

KABI=false

CTAGS=false

CSCOPE=false

ETAGS=false

DRY_RUN=

SIGNING_KEY=

while true; do

case "$1" in

-q)

QUIET=1

;;

-v)

QUIET=

;;

--quilt)

QUILT=true

;;

--no-quilt)

QUILT=false

;;

--combine)

# ignored

;;

--fast)

FAST=1

;;

--rapid)

RAPID=1

;;

--arch)

export PATCH_ARCH=$2

shift

;;

--symbol)

EXTRA_SYMBOLS="$EXTRA_SYMBOLS $2"

shift

;;

-d|--dir)

SCRATCH_AREA=$2

shift

;;

--vanilla)

VANILLA=true

;;

-F|--fuzz)

fuzz="-F$2"

shift

;;

--patch-dir)

PATCH_DIR=$2

shift

;;

--build-dir)

SP_BUILD_DIR="$2"

shift

;;

--config)

CONFIG="$2"

shift

;;

--kabi)

KABI=true

;;

--ctags)

CTAGS=true

;;

--cscope)

CSCOPE=true

;;

--etags)

ETAGS=true

;;

--dry-run)

DRY_RUN=--dry-run

;;

--signing-key)

SIGNING_KEY="$2"

shift

;;

--)

shift

break ;;

*)

usage ;;

esac

shift

done

unset LIMIT

if [ $# -ge 1 ]; then

LIMIT=$1

shift

fi

if ! [ -z "$DRY_RUN" -o -n "$FAST" -o -n "$RAPID" ]; then

echo "--dry-run requires --fast or --rapid"

exit 1

fi

if test -z "$CONFIG"; then

if test "$VANILLA_ONLY" = 1 || $VANILLA; then

CONFIG=$(uname -m)-vanilla

else

machine=$($(dirname $0)/arch-symbols)

if test -n "$VARIANT" -a -e "config/$machine/${VARIANT#-}"; then

CONFIG=$machine$VARIANT

elif test -e "config/$machine/default"; then

CONFIG=$machine-default

fi

if test -z "$CONFIG"; then

echo "Cannot determine default config for arch $machine"

fi

fi

fi

if test -n "$CONFIG"; then

CONFIG_ARCH=${CONFIG%%-*}

CONFIG_FLAVOR=${CONFIG##*-}

if [ "$CONFIG" = "$CONFIG_ARCH" -o "$CONFIG" = "$CONFIG_FLAVOR" -o \

-z "$CONFIG_ARCH" -o -z "$CONFIG_FLAVOR" ]; then

echo "Invalid config spec: --config=ARCH-FLAVOR is expected."

usage

fi

fi

if [ $# -ne 0 ]; then

usage

fi

# We need at least 2.7 now due to kselftests-kmp-default requiring

# selftests with the need to ensure scripts are execuable.

PATCH_VERSION_REQ="2.7"

PATCH_VERSION_REQ_LD_VERSION=$(echo $PATCH_VERSION_REQ | scripts/ld-version)

PATCH_VERSION=$(patch --version | head -1 | awk '{print $3}')

PATCH_VERSION_LD=$(echo $PATCH_VERSION | scripts/ld-version)

if [ $PATCH_VERSION_LD -lt $PATCH_VERSION_REQ_LD_VERSION ]; then

echo "$0 requires at least patch version $PATCH_VERSION_REQ"

exit 1

fi

# Check SCRATCH_AREA.

if [ -z "$SCRATCH_AREA" ]; then

echo "SCRATCH_AREA not defined (defaulting to \"tmp\")"

SCRATCH_AREA=tmp

fi

if [ ! -d "$SCRATCH_AREA" ]; then

if ! mkdir -p $SCRATCH_AREA; then

echo "creating scratch dir $SCRATCH_AREA failed"

exit 1

fi

fi

[ "${SCRATCH_AREA:0:1}" != "/" ] \

&& SCRATCH_AREA="$PWD/$SCRATCH_AREA"

TMPDIR=$SCRATCH_AREA

export TMPDIR

ORIG_DIR=$SCRATCH_AREA/linux-$SRCVERSION.orig

TAG=$(get_branch_name)

TAG=${TAG//\//_}

TAG=${TAG//\#/_}

if $VANILLA; then

TAG=${TAG}-vanilla

fi

PATCH_LOG=$SCRATCH_AREA/patch-$SRCVERSION${TAG:+-$TAG}.log

# Check series.conf.

if [ ! -r series.conf ]; then

echo "Configuration file \`series.conf' not found"

exit 1

fi

if [ -s extra-symbols ]; then

EXTRA_SYMBOLS="$EXTRA_SYMBOLS $(cat extra-symbols)"

fi

if [ -n "$EXTRA_SYMBOLS" ]; then

EXTRA_SYMBOLS=${EXTRA_SYMBOLS# }

echo "Extra symbols: $EXTRA_SYMBOLS"

SYMBOLS="$SYMBOLS $EXTRA_SYMBOLS"

fi

EXT=${EXTRA_SYMBOLS// /-}

EXT=${EXT//\//}

if test -z "$PATCH_DIR"; then

PATCH_DIR=$SCRATCH_AREA/linux-$SRCVERSION${TAG:+-$TAG}${EXT:+-}$EXT

fi

if [ -n "$SP_BUILD_DIR" ]; then

# This allows alias (~) and variable expansion

SP_BUILD_DIR=$(eval echo "$SP_BUILD_DIR")

else

SP_BUILD_DIR="$PATCH_DIR"

fi

if [ -z "$DRY_RUN" ]; then

echo "Creating tree in $PATCH_DIR"

# Clean up from previous run

rm -f "$PATCH_LOG"

if [ -e $PATCH_DIR ]; then

echo "Cleaning up from previous run"

rm -rf $PATCH_DIR

fi

fi

# Create fresh $SCRATCH_AREA/linux-$SRCVERSION.

if ! [ -d $ORIG_DIR ]; then

unpack_tarball "$SRCVERSION" "$ORIG_DIR" "$URL"

find $ORIG_DIR -type f -exec chmod a-w,a+r {} +

fi

if $VANILLA; then

PATCHES=( $(scripts/guards $SYMBOLS < series.conf | grep -E '^patches\.(kernel\.org|rpmify)/') )

else

PATCHES=( $(scripts/guards $SYMBOLS < series.conf) )

fi

# Check if patch $LIMIT exists

if [ -n "$LIMIT" ]; then

for ((n=0; n<${#PATCHES[@]}; n++)); do

if [ "$LIMIT" = - ]; then

LIMIT=${PATCHES[n]}

break

fi

case "${PATCHES[n]}" in

$LIMIT|*/$LIMIT)

LIMIT=${PATCHES[n]}

break

;;

esac

done

if [ -n "$LIMIT" ] && ((n == ${#PATCHES[@]})); then

echo "No patch \`$LIMIT' found."

exit 1

fi

PATCHES_BEFORE=()

for ((m=0; m<n; m++)); do

PATCHES_BEFORE[m]=${PATCHES[m]}

done

PATCHES_AFTER=()

for ((m=n; m<${#PATCHES[@]}; m++)); do

PATCHES_AFTER[m-n]=${PATCHES[m]}

done

else

PATCHES_BEFORE=( "${PATCHES[@]}" )

PATCHES_AFTER=()

fi

# Helper function to restore files backed up by patch. This is

# faster than doing a --dry-run first.

restore_files() {

local backup_dir=$1 patch_dir=$2 file

local -a remove restore

if [ -d $backup_dir ]; then

pushd $backup_dir > /dev/null

for file in $(find . -type f) ; do

if [ -s "$file" ]; then

restore[${#restore[@]}]="$file"

else

remove[${#remove[@]}]="$file"

fi

done

#echo "Restore: ${restore[@]}"

[ ${#restore[@]} -ne 0 ] \

&& printf "%s\n" "${restore[@]}" \

| xargs cp -f --parents --target $patch_dir

cd $patch_dir

#echo "Remove: ${remove[@]}"

[ ${#remove[@]} -ne 0 ] \

&& printf "%s\n" "${remove[@]}" | xargs rm -f

popd > /dev/null

fi

}

# Helper function to remove stray .rej files.

remove_rejects() {

local backup_dir=$1 patch_dir=$2 file

local -a remove

if [ -d $backup_dir ]; then

pushd $backup_dir > /dev/null

for file in $(find . -type f) ; do

if [ -f "$patch_dir/$file.rej" ]; then

remove[${#remove[@]}]="$file.rej"

fi

done

cd $patch_dir

#echo "Remove rejects: ${remove[@]}"

[ ${#remove[@]} -ne 0 ] \

&& printf "%s\n" "${remove[@]}" | xargs rm -f

popd > /dev/null

fi

}

if [ -z "$DRY_RUN" ]; then

# Create hardlinked source tree

echo "Linking from $ORIG_DIR"

cp -rld $ORIG_DIR $PATCH_DIR

# create a relative symlink

ln -snf ${PATCH_DIR#$SCRATCH_AREA/} $SCRATCH_AREA/current

else

PATCH_DIR="$ORIG_DIR"

fi

echo -e "# Symbols: $SYMBOLS\n#" > $PATCH_DIR/series

SERIES_PFX=

if ! $QUILT; then

SERIES_PFX="# "

fi

if [ -z "$DRY_RUN" ]; then

mkdir $PATCH_DIR/.pc

echo 2 > $PATCH_DIR/.pc/.version

fi

if [ -n "$FAST" ]; then

apply_fast_patches

elif [ -n "$RAPID" ]; then

apply_rapid_patches

else

apply_patches

fi

PATCHES=( ${PATCHES_AFTER[@]} )

if ! $QUILT && [ -z "$FAST$RAPID" ]; then

apply_rest_patches

fi

if [ -n "$DRY_RUN" ]; then

exit $status

fi

if [ -n "$EXTRA_SYMBOLS" ]; then

echo "$EXTRA_SYMBOLS" > $PATCH_DIR/extra-symbols

fi

if ! $QUILT; then

rm $PATCH_DIR/series

fi

ln -s $PWD $PATCH_DIR/patches

ln -s patches/scripts/{refresh_patch,run_oldconfig}{,.sh} $PATCH_DIR/

if $VANILLA; then

touch "$PATCH_DIR/.is_vanilla"

fi

if $QUILT; then

[ -r $HOME/.quiltrc ] && . $HOME/.quiltrc

[ ${QUILT_PATCHES-patches} != patches ] \

&& ln -s $PWD $PATCH_DIR/${QUILT_PATCHES-patches}

fi

echo "[ Tree: $PATCH_DIR ]"

if test "$SP_BUILD_DIR" != "$PATCH_DIR"; then

mkdir -p "$SP_BUILD_DIR"

echo "[ Build Dir: $SP_BUILD_DIR ]"

rm -f "$SP_BUILD_DIR/source"

rm -f "$SP_BUILD_DIR/patches"

ln -sf "$PATCH_DIR" "$SP_BUILD_DIR/source"

ln -sf "source/patches" "$SP_BUILD_DIR/patches"

cat > $PATCH_DIR/GNUmakefile <<EOF

ifeq (\$(filter tags TAGS cscope gtags, \$(MAKECMDGOALS)),)

ifndef KBUILD_OUTPUT

KBUILD_OUTPUT=$SP_BUILD_DIR

endif

endif

include Makefile

EOF

fi

# If there are any remaining patches, add them to the series so

# they can be fixed up with quilt (or similar).

if [ -n "${PATCHES[*]}" ]; then

( IFS=$'\n' ; echo "${PATCHES[*]}" ) >> $PATCH_DIR/series

fi

if test "0$status" -ne 0; then

exit $status

fi

if test -e supported.conf; then

echo "[ Generating Module.supported ]"

scripts/guards --list --with-guards < supported.conf | \

awk '

/\+external / {

print $(NF) " external";

next;

}

/^-/ {

print $(NF) " no";

next;

}

{

print $(NF);

}

' > "$SP_BUILD_DIR/Module.supported"

fi

if test -n "$CONFIG"; then

if test -e "config/$CONFIG_ARCH/$CONFIG_FLAVOR"; then

echo "[ Copying config/$CONFIG_ARCH/$CONFIG_FLAVOR ]"

if ! grep -q CONFIG_MMU= "config/$CONFIG_ARCH/$CONFIG_FLAVOR"; then

if [ "$CONFIG_ARCH" = "i386" ]; then

config_base="config/$CONFIG_ARCH/pae"

else

config_base="config/$CONFIG_ARCH/default"

fi

scripts/config-merge "$config_base" \

"config/$CONFIG_ARCH/$CONFIG_FLAVOR" \

> "$SP_BUILD_DIR/.config"

else

cp -a "config/$CONFIG_ARCH/$CONFIG_FLAVOR" "$SP_BUILD_DIR/.config"

fi

else

echo "[ Config $CONFIG does not exist. ]"

fi

if $KABI; then

if [ ! -x rpm/modversions ]; then

echo "[ This branch does not support the modversions kABI mechanism. Skipping. ]"

elif [ -e "kabi/$CONFIG_ARCH/symtypes-$CONFIG_FLAVOR" ]; then

echo "[ Expanding kABI references for $CONFIG ]"

rpm/modversions --unpack "$SP_BUILD_DIR" < \

"kabi/$CONFIG_ARCH/symtypes-$CONFIG_FLAVOR"

else

echo "[ No kABI references for $CONFIG ]"

fi

fi

if test -f ${PATCH_DIR}/scripts/kconfig/Makefile && \

grep -q syncconfig ${PATCH_DIR}/scripts/kconfig/Makefile; then

syncconfig="syncconfig"

else

syncconfig="silentoldconfig"

fi

test "$SP_BUILD_DIR" != "$PATCH_DIR" && \

make -C $PATCH_DIR O=$SP_BUILD_DIR -s $syncconfig

fi

filter_fingerprints() {

grep 'SHA1 Fingerprint' | sed -e 's/SHA1 Fingerprint.//' | \

tr -d ' :' | tr a-z A-Z

}

cert_fingerprint() {

local cert=$1

openssl x509 -fingerprint -noout -in "$cert" | filter_fingerprints

}

cert_fingerprint8() {

local cert=$1

cert_fingerprint "$cert" | cut -b 1-8

}

cert_signature_algo() {

local cert=$1

# openssl doesn't have a way to just show the algo

openssl x509 -noout -text -in "$cert" | grep 'Signature Algorithm' | \

tr -d ' ' | uniq | cut -d ':' -f 2

}

get_config_option() {

local config=$1

local option=$2

sed -n "/^CONFIG_$option=/s///p" "$config" |tr -d '"' | tail -1

}

set_config_option() {

local config=$1

local option=$2

local value=$3

sed -i -e "/^CONFIG_$option=/s;=.*;=$value;" "$config"

}

set_config_option_string() {

local config=$1

local option=$2

local value=$3

set_config_option "$config" "$option" "\"$value\""

}

copy_signing_key() {

local cert=$1

echo "[ Copying signing key $SIGNING_KEY ]"

if ! test -f "$cert"; then

echo "*** ERROR: Signing key $cert does not exist"

return

fi

keyexts=$(openssl x509 -in $cert -ext keyUsage,extendedKeyUsage -noout)

if ! echo $keyexts | grep -q "Code Signing"; then

echo "*** WARNING: Signing key must have extendedKeyUsage=codeSigning" \

"to be used to sign kernel for Secure Boot" >&2

fi

if ! echo $keyexts | grep -q "Digital Signature"; then

echo "*** WARNING: Signing key must have keyUsage=digitalSignature" \

"to be used to sign modules" >&2

fi

mkdir -p "$SP_BUILD_DIR/certs"

certname="$(cert_fingerprint8 "$cert").pem"

cp "$cert" "$SP_BUILD_DIR/certs/$certname"

if test -z "$CONFIG"; then

echo "*** WARNING: signing key copied to certs/$certname but" \

"no config available to enable"

return

fi

local config="$SP_BUILD_DIR/.config"

# Check for algo compatibility

config_algo="$(get_config_option $config MODULE_SIG_HASH)"

if test -z "$config_algo"; then

echo "*** WARNING: Module signing is disabled in active config"

return

fi

cert_algo=$(cert_signature_algo $cert)

cert_algo=${cert_algo%%WithRSAEncryption}

if test "$config_algo" != "$cert_algo"; then

echo "*** WARNING: Signing key uses hash algo '$cert_algo' but" \

" kernel config uses '$config_algo'"

fi

set_config_option_string $config MODULE_SIG_KEY "certs/$certname"

}

if test -n "$SIGNING_KEY"; then

copy_signing_key $SIGNING_KEY

fi

# Some archs we use for the config do not exist or have a different name in the

# kernl source tree

case $CONFIG_ARCH in

s390x) TAGS_ARCH=s390 ;;

ppc64|ppc64le) TAGS_ARCH=powerpc ;;

*) TAGS_ARCH=$CONFIG_ARCH ;;

esac

if $CTAGS; then

if ctags --version > /dev/null; then

echo "[ Generating ctags (this may take a while)]"

ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" tags

else

echo "[ Could not generate ctags: ctags not found ]"

fi

fi

if $CSCOPE; then

if cscope -V 2> /dev/null; then

echo "[ Generating cscope db (this may take a while)]"

ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" cscope

else

echo "[ Could not generate cscope db: cscope not found ]"

fi

fi

if $ETAGS; then

if etags --version > /dev/null; then

echo "[ Generating etags (this may take a while)]"

ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" TAGS

else

echo "[ Could not generate etags: etags not found ]"

fi

fi