run.sh

#!/bin/bash

build() {
	# make libcompel
	make -j `nproc` -C $CRIU_SRC

	# clean firstly to avoid using obsolete files (w/o update libcompel)
	make -j `nproc` -C $PSTREE_HOME clean
	make -j `nproc` -C $PSTREE_HOME
}

kill_container() {
	# kill running container
	runnings=`runc list | grep -e $TMPL -e $FORK | awk '{print $1}'`
	for running in $runnings; do
		echo "deleteing container $running ..."
		runc delete -f $running > /dev/null 2>&1
	done
}

setup_xfs_device() {
	# XFS_DEVICE_RELATED
	# the file to be losetup as LOOP_DEVICE
	local XFS_IMG_FILE="/tmp/xfs-loop.img"
	local LOOP_DEVICE="/dev/loop100"
	# the mountpoint of xfs filesystem
	local XFS_DISK="/tmp/xfs_disk"
	local XFS_TEST_SRC=$XFS_DISK/$RELATIVE_TEST_PATH
	local XFS_PSTREE_FORK_SRC=$XFS_TEST_SRC/../

	# for xfs mode, we do two things:
	# 1. make out a xfs disk to test
	# 2. change global variable with xfs version
	# We can skip step1 if xfs disk exists.
	device_ready=`mount -t xfs | grep $XFS_DISK`
	if [ -z "$device_ready" ]; then
		umount $XFS_DISK
		losetup -d $LOOP_DEVICE
		rm $XFS_DISK $XFS_IMG_FILE -rf

		# mkfs xfs and mount
		mkdir -p $XFS_DISK
		dd if=/dev/zero of=$XFS_IMG_FILE bs=1G count=1
		mkfs.xfs  -m reflink=1 $XFS_IMG_FILE
		losetup $LOOP_DEVICE $XFS_IMG_FILE
		mount -t xfs $LOOP_DEVICE $XFS_DISK

		# copy source code of pstree-fork to xfs_disk
		mkdir -p $XFS_PSTREE_FORK_SRC
		cp -r $PSTREE_HOME $XFS_PSTREE_FORK_SRC
	fi

	TEST_SRC=$XFS_TEST_SRC
	PSTREE_HOME=$XFS_PSTREE_FORK_SRC
	LOWDIR=$XFS_DISK/"debian-rootfs"
	TEST_DIR=$XFS_DISK/"pstree-fork-test"
	cd $XFS_TEST_SRC
}

prepare_lowdir() {
	lowdir=$1
	rm $lowdir -rf
	mkdir -p $lowdir

	debian_id=$(docker ps -a | grep debian | head -1 | awk '{print $1}')
	if [ -z $debian_id ]; then
		docker build -t debian-cntr ./configs
		debian_id=$(docker create debian-cntr)
	fi

	docker export $debian_id | tar -C $lowdir -xvf - >/dev/null 2>&1
}

raise_cap() {
	for i in $RAISE_CAP_TESTCASES
	do
		[ "$i" == "$TEST_CASE" ] &&
		sed -i '/'\"bounding\":'/a\\t\t\t\t"CAP_SYS_ADMIN",' $1 &&
		sed -i '/'\"effective\":'/a\\t\t\t\t"CAP_SYS_ADMIN",' $1 &&
		sed -i '/'\"permitted\":'/a\\t\t\t\t"CAP_SYS_ADMIN",' $1 &&
		sed -i '/'\"ambient\":'/a\\t\t\t\t"CAP_SYS_ADMIN",' $1
	done
}

create_target_containers() {
	lowdir=$LOWDIR
	testdir=$TEST_DIR
	nr=$batch

	if [ -z $batch ]; then
		nr=1
	fi

	for i in $(seq $nr); do
		oldpath=`pwd`
		cpath=$FORK_CPATH"."$i
		cname=$FORK$i
		umount $testdir/$cpath/rootfs

		# prepare rootfs for forked-container
		cd $testdir
		rm $cpath -rf
		mkdir $cpath
		cd $cpath
		mkdir work rootfs
		cp -r -p $testdir/$TMPL_CPATH/upper $testdir/$cpath/
		mount -t overlay overlay -o lowerdir=$lowdir,upperdir=./upper,workdir=./work ./rootfs
		cp $TEST_SRC/configs/forked_config.json config.json
		sed -i -e "s/forked/${cname}/g" config.json
		sed -i -e "s@debuglog@${DEBUG_LOG}@g" config.json
		raise_cap config.json
		runc run -d $cname
		cd $oldpath
	done
}

create_container() {
	lowdir=$LOWDIR
	testdir=$TEST_DIR
	oldpath=`pwd`

	umount $testdir/$TMPL_CPATH/rootfs
	mkdir -p $testdir
	cd $testdir
	rm $TMPL_CPATH -rf

	if [ ! -f $DEBUG_LOG ]; then
		mkdir -p $TEST_SRC/output
		touch $DEBUG_LOG
	fi

	# prepare rootfs for template-container
	mkdir $TMPL_CPATH
	cd $TMPL_CPATH
	mkdir upper work rootfs
	mount -t overlay overlay -o lowerdir=$lowdir,upperdir=./upper,workdir=./work ./rootfs
	cp $TEST_SRC/configs/template_config.json config.json
	sed -i -e "s/template/${TMPL}/g" config.json
	sed -i -e "s@debuglog@${DEBUG_LOG}@g" config.json
	raise_cap config.json
	cp $TEST_BIN rootfs/usr/bin/victim
	runc run -d $TMPL
	cd $oldpath

	# wait for template containers complete creating files in upper
	sleep 1

	# wait util container are fully started
	create_target_containers
	sleep 0.5

	# show containers
	runc list | grep -e $TMPL -e $FORK
}

show_pstree() {
	echo -e "\n"
	if [ $tmpl_cpid -ne 0 ]; then
		pstree -p $tmpl_cpid
	fi

	for pid in $fork_cpid; do
		pstree -p $pid
	done
}

pstree_fork() {
	# sanity check
	echo -e "\n\n######## sanity check log ######## \n\n"
	$PSTREE_HOME/pstree-fork -t $tmpl_cpid -c
	if [ $? -ne 0 ]; then
		echo "TEST_UNSUPPORTED"
		exit 1
	fi

	echo -e "\n\n######## pstree-fork log ########\n\n"
	if [ -z $batch ]; then
		$PSTREE_HOME/pstree-fork -t $tmpl_cpid -d $fork_cpid -l $loglevel
		return
	fi

	# kill all exist pstree-fork server
	killall -9 pstree-fork

	# server mode
	response=$TEST_SRC/response
	pid_file=$TEST_SRC/pid_file
	rm -rf $UDS_PATH $response $pid_file
	$PSTREE_HOME/pstree-fork -t $tmpl_cpid -s $UDS_PATH  -l $loglevel &

	sleep 0.5

	for pid in $fork_cpid; do
		echo "dst_ppid:${pid}" >> $pid_file
	done

	$TEST_SRC/tools/pstree_fork_client $UDS_PATH $pid_file > $response 2>&1
}

send_sigusr1() {
	for pid in $fork_cpid; do
		forked_victim=`ps -ef | grep -w $pid | grep victim | awk '{print $2}'`
		echo -e "\nSending SIGUSR1 to newly forked process $forked_victim, target container $pid"
		kill -SIGUSR1 $forked_victim
	done
}

usage() {
	echo "Usage: $0 [-x] [-s] [-p] [test_case]";
	echo "       -x: run in xfs filesystem"
	echo "       -s: skip build and prepare stage"
	echo "       -p: run performance test"
	exit 1;
}


# should run test as root
if [ `whoami` = "root" ];then
	echo "root verified"
else
	sudo bash -c "$0 $*"
	exit
fi

# this may be changed by xfs mode, so put it here.
TEST_SRC=`pwd`
RELATIVE_TEST_PATH=$(basename "$(dirname "$TEST_SRC")")/$(basename "$TEST_SRC")
PSTREE_HOME=$TEST_SRC/../
CRIU_SRC=$PSTREE_HOME/criu/
LOWDIR="/tmp/debian-rootfs"
TEST_DIR="/tmp/pstree-fork-test"

while getopts "xspb:" o; do
	case "${o}" in
	x)
		setup_xfs_device
		;;
	s)
		skip=true
		;;
	p)
		perf=true
		;;
	b)
		batch=$OPTARG
		;;
	*)
		usage
		exit
		;;
	esac
done
shift $((OPTIND-1))

TEST_CASE=$1
TEST_BIN=$TEST_SRC/static/$TEST_CASE
loglevel=4

if [ -z $TEST_CASE ]; then
	TEST_CASE=victim
	TEST_BIN=$TEST_SRC/tools/victim
fi

if [ ! -z $perf ]; then
	TEST_CASE=perf
	TEST_BIN=$TEST_SRC/tools/perf
	loglevel=0
fi

TMPL=tmpl_${TEST_CASE}.cntr
FORK=fork_${TEST_CASE}.cntr
TMPL_CPATH=tmpl_cntr_${TEST_CASE}
FORK_CPATH=fork_cntr_${TEST_CASE}
UDS_PATH="/var/run/pstree-fork.sock"
DEBUG_LOG=${TEST_SRC}/output/${TEST_CASE}.log
RAISE_CAP_TESTCASES="shmemfd-priv shmemfd maps01 pipe03"

if [ -z $skip ]; then
	build
	prepare_lowdir $LOWDIR
fi

if [ ! -f $TEST_BIN ]; then
	echo -e "\nTest case $TEST_BIN doesn't exist!\n"
	exit
fi

kill_container
create_container

tmpl_cpid=`sudo runc list | grep $TMPL | awk '{print $2}'`
fork_cpid=`sudo runc list | grep $FORK | awk '{print $2}'`

pstree_fork
show_pstree
# kick victim to let test go
send_sigusr1