kabi-graph

#!/bin/bash
#
# kabitools
#

declare cmdline=kabitools
declare -i cpus=$(cat /proc/cpuinfo | grep processor | wc -l)
declare clean=true
declare patch
declare target=""
declare distro="$(cat /etc/os-release | grep -w ID | cut -d'=' -f2)"

declare -i optcnt=0

declare -i err_no_patch=1
declare -i err_no_os=2
declare -i err_not_kernel=3
declare -i err_not_redhat=4
declare -i err_no_boost=5
declare -i err_bad_opt=127
declare -i CTRL_C=130

declare BLD="\033[1m"
declare OFF="\033[0m"
declare UND="\033[4m"

declare graphlist="redhat/kabi/kabi-datafiles.list"
declare graphext="kbg"

# strip outside quotes from the distro string
#
distro=$(sed -e 's/^"//' -e 's/"$//' <<<"$distro")


usagestr=$(
cat <<EOF
$BLD
$(basename $0) -[jnDh] [target]$OFF

	Builds a graph from the preprocessor output of each file compiled.
	Must be invoked from the top of the kernel tree.

	The optional $BLD\0target$OFF argument can be any valid kernel make target
	including a subdirectory, e.g. "$BLD\0virt/$OFF" or a module build, e.g.
	"$BLD\0M=drivers/char/tpm$OFF"

	The kABI graph will be limited to the scope of the build of the
	optional target.

	Default action without the optarg:
		make clean	# can be disabled with -n option
		make
		make modules

	$UND\0Options$OFF
$BLD	-j$OFF	- Optional number of processors to assign to the make task.
		  There must be a space between -j and the number.
		  Default is all processors in this system: $BLD$cpus$OFF

$BLD	-n$OFF	- Do not make clean first
$BLD	-R$OFF	- Recreate the list of graph files: $graphlist
$BLD	-D$OFF	- Delete all the graph files and exit.
$BLD	-h$OFF	- This help screen.
	$BLD
	NOTE:$OFF	The graph file extension will be added to $BLD\0.git/info/exclude$OFF,
		but will be selectively removed with "$BLD\0kabi-graph -D$OFF" command,
		which removes all the graph files.
\0
EOF
)

no_patch_str=$(
cat <<EOF

$BLD$(basename $0)$OFF could not find the correct patch for the kernel Makefiles.

Please check for the existence of:
$BLD
/usr/share/kabitools-rhel-kernel-make.patch
/usr/share/kabitools-pegas-kernel-make.patch$OFF
\0
EOF
)

no_os_str=$(
cat <<EOF

$BLD$(basename $0)$OFF does not handle distro: $BLD$distro$OFF
\0
EOF
)

not_kernel_str=$(
cat <<EOF

$BLD$(basename $0)$OFF must be invoked from the top of a kernel tree.

You are here: $BLD$PWD$OFF
\0
EOF
)

not_redhat_str=$(
cat <<EOF

$BLD$(basename $0)$OFF must be invoked from the top of a RHEL tree.

Your current distro is: "$BLD$distro$OFF"
Your current branch is: "$BLD$(git rev-parse --abbrev-ref HEAD)$OFF"
\0
EOF
)

no_boost_str=$(
cat <<EOF

You must install $BLD\0boost$OFF before you can run $BLD$(basename $0)$OFF\0.
\0
EOF
)

usage() {
	echo -e "$usagestr"
	exit 0
}

errexit() {
	echo -e "$1"
	exit $2
}

# ui_waitonproc
#
# Prints a dot to the screen every half second until the passed PID
# completes.
#
# $1 - PID of process we are waiting for.
# $2 - optional time argument
#
ui_waitonproc() {
    __pid__=$1;
    __time__=1

    [ $# -eq 2 ] && __time__=$2
    while kill -0 $__pid__ > /dev/null 2>&1; do
        echo -n '.';
        sleep $__time__;
    done
}

# delete_linen - deletes the line 'n' from the file
#
# $1 - number of the line to delete
# $2 - file from which to delete the line
#
delete_linen() {
	local tfil="/tmp/__temp__file__"
	local mode=$(stat --format '%a' $2)

	touch $tfil
	chmod $mode $tfil

	awk -v line=$1 '{
		if (NR != line) {
			print $0;
		}
	}' $2 > $tfil
	mv $tfil $2
}

# find_line - return the 1-based line number of the string in the file
#
# Sends a 0 to $3 if not found
#
# $1 - string
# $2 - file
# $3 - number, receives the line number, 0 if not found
#
find_line() {
	local _line_="$1"
	local _file_="$2"
	local _number_

	_line_=$(grep -n "$_line_" "$_file_")
	[ $? -eq 0 ] || { eval $3=0; return 1; }
	_number_=$(echo "$_line_" | cut -d':' -f1)
	eval $3=$_number_
	return 0
}

delete_graph() {
	local mypid
	local linenum
	local line

	echo -n "Deleting graph files.."
	find . -name \*.kbg -exec rm -f '{}' \; &
	mypid=$!
	ui_waitonproc mypid .1
	rm -f redhat/kabi/kabi-datafiles.list

	# delete the kabi-graph lines from .git/info/exclude
	#
	find_line '\*.kbg' .git/info/exclude linenum
	[ $linenum -gt 0 ] && delete_linen $linenum .git/info/exclude
	find_line 'redhat/kabi/kabi-datafiles.list' .git/info/exclude linenum
	[ $linenum -gt 0 ] && delete_linen $linenum .git/info/exclude

	echo
	echo "Done!"
	exit 0
}

recreate_graphlist() {
	local mypid
	> "$graphlist"
	find ./ -name "*.kbg" -exec echo '{}' >> "$graphlist" \; &
	mypid=$!
	ui_waitonproc $mypid .1
	echo "Done."
	exit 0
}


# run if user hits control-c
#
control_c() {
	echo -en "\nCtrl-c detected\nCleaning up and exiting.\n"
	patch -Rs -p1 < "$patch"
	errexit "Done." $CTRL_C
}

main() {
	local kerneltree
	local linenumber
	local rhel
	local kernel

	# Make sure that we have boost-serialization. Can't work without it.
	#
	rpm -q boost-serialization > /dev/null 2>&1
	[ $? -eq 0 ] || errexit "$no_boost_str" $err_no_boost

	# Determine if we're in a Linux Kernel directory
	#
	[ -f README ] || errexit "$not_kernel_str" $err_not_kernel
	kerneltree="$(head -1 README)"
	kerneltree=$(echo $kerneltree)
	[[ ${kerneltree:0:12} == "Linux kernel" ]] || \
		errexit "$not_kernel_str" $err_not_kernel

	# Make sure that we are in a rhel or fedora tree
	#
	[ -d redhat ] || errexit "$not_redhat_str" $err_not_redhat

	while getopts hnRDj: OPTION; do
	    case "$OPTION" in

		h ) 	usage
			;;
		j )	cpus=$OPTARG
			optcnt=$((optcnt + 2))
			;;
		n )	clean=false
			optcnt=$((optcnt + 1))
			;;
		R )	recreate_graphlist
			;;
		D )	delete_graph
			;;
		* )	usage
			errexit "Unrecognized option." $err_bad_opt
	    esac
	done

	shift $optcnt
	target="$1"

	kernel=$(grep -m1 VERSION Makefile | cut -d' ' -f3)

	case $kernel in

	    # RHEL6 and RHEL7 share the same Makefile patch
	    #
	    2 )	patch="/usr/share/kabitools-rhel7-kernel-make.patch"
			;;
	    3 )	patch="/usr/share/kabitools-rhel7-kernel-make.patch"
			;;
	    4 )	patch="/usr/share/kabitools-rhel8-kernel-make.patch"
			;;
	    * )	errexit "$no_patch_str" $err_no_patch
	esac

	[ -f "$patch" ] || errexit "$no_os_str" $err_no_os

	patch -s -p1 < "$patch"

	$clean && make clean
	> redhat/kabi/kabi-datafiles.list
	make -j $cpus K=1 $target
	patch -Rs -p1 < "$patch"

	# If we haven't already done so, then add the graph file extensions
	# to .git/info/exclude
	#
	find_line "\*.$graphext" .git/info/exclude linenumber
	[ $linenumber -eq 0 ] && echo "*.$graphext" >> .git/info/exclude

	find_line "$graphlist" .git/info/exclude linenumber
	[ $linenumber -eq 0 ] && echo "$graphlist" >> .git/info/exclude

	exit 0
}

# trap keyboard interrupt (control-c)
#
trap control_c SIGINT

# Call the main function.
#
main $@