xref: /third_party/ltp/testcases/kernel/controllers/freezer/libcgroup_freezer

#!/bin/bash
# Copyright (c) International Business Machines  Corp., 2008
# Author: Matt Helsley <matthltc@us.ibm.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#

# A library of cgroup test functions for testing the cgroup freezer and,
# if present, a cgroup signal subsystem.
#
# Most of these assume the current directory is the cgroup of interest.
# mount_{freezer|signal} and make_sample_cgroup are the exceptions to this rule.
#
# On failure, a message indicating what failed is printed and the
#    exit status of the failing command is returned. If "result" is unset
#    then we assign the exit status of the failed command to it.
#
# The variable "result" holds the exit status of the first command that failed,
#    $UNFINISHED if no command has failed yet, or $FINISHED if no command
#    has failed and we've finished all significant parts of the test. Note:
#    significant parts usually do not include the cleanup of the test.
#


# xargs 4.1.20 only accepts -i instead of -I
# However -I is added and -i deprecated somewhere between (4.1.20, 4.2.32]
XRGSV=$(xargs --version | sed -e 's/^[^[:digit:]]*//')
export XARGS_REPL_STR="%"
case ${XRGSV} in
[456789].[23456789][0-9]*.*|[1-9][0-9][0-9]*.*.*) # version > 4.1.*
	export XARGS_REPL_OPT="-I${XARGS_REPL_STR}"
	;;
4.1.*|*)
	export XARGS_REPL_OPT="-i${XARGS_REPL_STR}"
	;;
esac
unset XRGSV

export UNFINISHED=""
export FINISHED=0
export TMP=${TMP:-/tmp}

#
# Tests are either running or cleaning up. Cleanup phases do not emit TFAIL.
#
export LIB_TEST_STATE="running"

export max_state_samples=5 # number of times to sample
export sample_state_period=1  # number of seconds between samplings
export sample_sleep=5     # how long the sample program should sleep
export result="$UNFINISHED"

# These are echo'd to freezer.state.
export FREEZE='FROZEN'
export THAW='THAWED'

# We use /bin/echo to write to cgroup files because it's exit status will not
# hide write errors (bash's echo does not indicate if the write succeeded).
export CG_FILE_WRITE=/bin/echo

declare -r UNFINISHED FINISHED FREEZE THAW max_state_samples sample_state_period

# When we're running we want to issue failure results when things go wrong.
function running_cgroup_test()
{
	export LIB_TEST_STATE="TFAIL"
}

# But when we're cleaning up we want to issue warnings (if not TINFO).
function cleanup_cgroup_test()
{
	export LIB_TEST_STATE="TWARN"
}

# Mounts the cgroup filesystem somewhere and pushes pwd onto the dir stack
function mount_cgroup_subsys()
{
	local rc=0

	mkdir -p $TMP/${cgroup_subsys}_test > /dev/null 2>&1
	rc=$?

	# Don't test status because we don't care if the directory already
	# exists.

	if [ ! -d $TMP/${cgroup_subsys}_test ]; then
		result=${result:-$rc}
		tst_brkm TBROK "Failed to make mount point for cgroup filesystem"
		return $result
	fi

	mount -t cgroup -o${cgroup_subsys} test_cgroup_${cgroup_subsys} $TMP/${cgroup_subsys}_test
	rc=$?
	if [ $rc -ne 0 ]; then
		result=${result:-$rc}
		tst_resm TINFO "Failed to mount cgroup filesystem with ${cgroup_subsys} subsystem."
		rmdir $TMP/${cgroup_subsys}_test 2> /dev/null
		return $rc
	fi

	export mount_cgroup_freezer_saved_dir="$(pwd)"
	cd $TMP/${cgroup_subsys}_test > /dev/null 2>&1
	rc=$?
	if [ $rc -ne 0 ]; then
		result=${result:-$rc}
		tst_brkm TBROK "Failed to change working directory into cgroup filesystem (pwd: \"$(pwd)\")"
		umount $TMP/${cgroup_subsys}_test || umount -l $TMP/${cgroup_subsys}_test || tst_brkm TBROK "Failed to unmount cgroup filesystem with ${cgroup_subsys} subsystem"
		rmdir $TMP/${cgroup_subsys}_test 2> /dev/null
		return $rc
	fi

	return 0
}

function mount_freezer()
{
	export cgroup_subsys=freezer
	mount_cgroup_subsys
}

function mount_signal()
{
	export cgroup_subsys=signal
	mount_cgroup_subsys
}

# umounts the cgroup filesystem and pops the dir stack
function umount_cgroup_subsys()
{
	cd "${mount_cgroup_freezer_saved_dir}"
	local cwd_result=$?
	umount $TMP/${cgroup_subsys}_test > /dev/null 2>&1 \
	  || umount -l $TMP/${cgroup_subsys}_test || \
	    tst_brkm TBROK "Failed to unmount cgroup filesystem (umount exit status: $?)"
	local umnt_result=$?
	local rc=0

	if [ $cwd_result -ne 0 ]; then
		result=${result:-$cwd_result}
		rc=$cwd_result
	elif [ $umnt_result -ne 0 ]; then
		result=${result:-$umnt_result}
		rc=$umnt_result
	elif [ $umnt_result -eq 0 -a $cwd_result -eq 0 ]; then
		rmdir $TMP/${cgroup_subsys}_test
		return 0
	fi

	return $rc
}

function umount_freezer()
{
	[ "${cgroup_subsys}" != "freezer" ] && {
		result=${result:-5}
		exit -1
	}
	umount_cgroup_subsys
	unset cgroup_subsys
}

function cleanup_freezer()
{
	local save_result="${result}"
	local save_pwd="$(pwd)"

	mount_freezer && {
		# Run these commands in bash because we need $(cmd subst) and
		# we need to redirect to different freezer.state files for each
		# group
		# Kill any leftover tasks
		disown -a
		find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | \
		xargs -0r -n 1 ${XARGS_REPL_OPT} /bin/bash -c 'kill $(cat "'"${XARGS_REPL_STR}"'/tasks") 2> /dev/null'

		# For each group in the freezer hierarch, that its tasks
		find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | \
		xargs -0r -n 1 ${XARGS_REPL_OPT} /bin/bash -c "\"${CG_FILE_WRITE}\" \"${THAW}\" > '${XARGS_REPL_STR}/freezer.state'"

		# Kill any leftover tasks
		find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | \
		xargs -0r -n 1 ${XARGS_REPL_OPT} /bin/bash -c 'kill $(cat "'"${XARGS_REPL_STR}"'/tasks") 2> /dev/null'

		sleep 2

		# Really kill any leftover tasks
		find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | \
		xargs -0r -n 1 ${XARGS_REPL_OPT} /bin/bash -c 'kill -s SIGKILL $(cat "'"${XARGS_REPL_STR}"'/tasks") 2> /dev/null'

		# Don't need to run these xargs commands in bash since we want
		# to see what's left on stdout
		LINES=$(find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | \
			xargs -0r -n 1 ${XARGS_REPL_OPT} cat "${XARGS_REPL_STR}/tasks" | wc -l)
		if (( LINES == 0 )); then
			# Remove the empty groups
			find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | xargs -r0 rmdir
		else
			tst_resm TWARN "Could not cleanup:"
			find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | xargs -0r -n 1 ${XARGS_REPL_OPT} ls -ld "${XARGS_REPL_STR}/tasks"
		fi

		umount_freezer
	}

	if [ "$save_pwd" != `pwd` ]; then
		tst_resm TWARN "libcgroup_subsys: cleanup_freezer() is broken"
		cd "$save_pwd"
	fi

	result="${save_result}"
}

function umount_signal()
{
	[ "${cgroup_subsys}" != "signal" ] && {
		result=${result:-6}
		exit -1
	}
	umount_cgroup_subsys
	unset cgroup_subsys
}

function cleanup_signal()
{
	local save_result="${result}"
	local save_pwd="$(pwd)"

	mount_signal && {
		find $TMP/${cgroup_subsys}_test -mindepth 1 -depth -type d -print0 | xargs -r0 rmdir
		umount_signal
	}

	if [ "$save_pwd" != `pwd` ]; then
		tst_resm TWARN "libcgroup_subsys: cleanup_signal() is broken"
		cd "$save_pwd"
	fi
	result="${save_result}"
}

function assert_cgroup_rwfile()
{
	local file="$1"
	local descr="$2"
	local rc=0

	if [ ! -e "${file}" ]; then
		tst_resm ${LIB_TEST_STATE} "$descr missing"
		rc=1
	fi

	if [ ! -f "${file}" ]; then
		tst_resm ${LIB_TEST_STATE} "$descr is not a regular file"
		rc=2
	fi

	if [ ! -r "${file}" ]; then
		tst_resm ${LIB_TEST_STATE} "$descr is not readable"
		rc=3
	fi

	if [ ! -w "${file}" ]; then
		tst_resm ${LIB_TEST_STATE} "$descr is not writeable"
		rc=4
	fi

	[ $rc -ne 0 ] && {
		result=${result:-$rc}
		local s="$(stat "${file}")"
		tst_resm ${LIB_TEST_STATE} "${s}"
	}

	return $rc
}

function assert_cgroup_tasks_rwfile()
{
	assert_cgroup_rwfile "tasks" "task list"
	return $?
}

function dump_named_cgroup_tasks()
{
	local cgroup_name="$1"
	local tasks

	tasks=( $(cat "${cgroup_name}/tasks") ) # don't assign directly (bash bug)
	if [ -z "${tasks[*]}" ]; then
		return 0
	fi
	ps -p "${tasks[*]}" -o 'pid,ppid,pgid,tid,tpgid,blocked,ignored,pending,stat,tty,args'
}

function dump_cgroup_tasks()
{
	dump_named_cgroup_tasks "$(pwd)"
}

function assert_cgroup_tasks_empty()
{
	local nlines=$(( `cat tasks | wc -l` + 0))
	local rc=$?

	[ $rc -eq 0 -a $nlines -eq 0 ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "cgroup task list is not empty: "
	dump_cgroup_tasks 1>&2
	return $rc
}

function assert_task_in_named_cgroup()
{
	local task_pid=$1
	local cgroup_name="$2"

	cat "${cgroup_name}/tasks" | grep -E "^${task_pid}\$" > /dev/null 2>&1 && return 0
	local rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected pid ${task_pid} is not in \"${cgroup_name}\" task list"
	dump_named_cgroup_tasks "${cgroup_name}" 1>&2
	return $rc
}

function assert_task_not_in_named_cgroup()
{
	local task_pid=$1
	local cgroup_name="$2"

	cat "${cgroup_name}/tasks" | grep -E "^${task_pid}\$" > /dev/null 2>&1 || return 0
	local rc=1 # $? == 0 is an error in this case
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected pid ${task_pid} is in \"${cgroup_name}\" task list"
	dump_named_cgroup_tasks "${cgroup_name}" 1>&2
	return $rc
}

function assert_task_in_cgroup()
{
	assert_task_in_named_cgroup $1 "$(pwd)"
	return $?
}

function assert_task_not_in_cgroup()
{
	assert_task_not_in_named_cgroup $1 "$(pwd)"
	return $?
}

function assert_sample_proc_in_cgroup()
{
	assert_task_in_cgroup $sample_proc
	return $?
}

function assert_sample_proc_not_in_cgroup()
{
	assert_task_not_in_cgroup $sample_proc
	return $?
}

function assert_sample_proc_in_named_cgroup()
{
	assert_task_in_named_cgroup $sample_proc "$1"
	return $?
}

function assert_sample_proc_not_in_named_cgroup()
{
	assert_task_not_in_named_cgroup $sample_proc "$1"
	return $?
}

function get_task_state()
{
	ps -p $1 -o 'state=' 2>/dev/null
}

# TODO Check: Do these need to ignore case differences?
function assert_task_state()
{
	local task_pid=$1
	local expected_state="$2"
	local ps_state="$(get_task_state ${task_pid})"
	local rc=$?

	[ $rc -eq 0 -a "$ps_state" == "${expected_state}" ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected task ${task_pid} to be in state \"${expected_state}\""
	return $rc
}

#
# Check that the specified task is not in the specified state
#
function assert_task_not_in_state()
{
	local task_pid=$1
	local expected_state="$2"
	local ps_state="$(get_task_state ${task_pid})"
 	local rc=$?

	[ $rc -eq 0 -a "$ps_state" != "${expected_state}" ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected task ${task_pid} to not be in state \"${expected_state}\""
	return $rc
}

#
# Frozen tasks are in the "D" state according to ps
# tasks in "T" state may also be in a "frozen" state
#
function assert_task_not_frozen()
{
	local task_pid=$1
	local ps_state="$(ps -p $task_pid -o 'state=')"
	local rc=$?

	[ $rc -eq 0 -a "$ps_state" != "D" ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected task ${task_pid} is not frozen (unexpected task state: \"$ps_state\")"
	return $rc
}

function assert_task_is_frozen()
{
	local task_pid=$1
	local ps_state="$(ps -p $task_pid -o 'state=')"
	local rc=$?

	[ $rc -eq 0 -a "$ps_state" == "D" -o "$ps_state" == "T" ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected task ${task_pid} to be frozen (unexpected task state: \"$ps_state\")"
	return $rc
}

function assert_sample_proc_not_frozen()
{
	assert_task_not_frozen $sample_proc
	return $?
}

function assert_sample_proc_is_frozen()
{
	assert_task_is_frozen $sample_proc
	return $?
}

function assert_sample_proc_stopped()
{
	assert_task_state $sample_proc 'T'
	return $?
}

function assert_sample_proc_not_stopped()
{
	assert_task_not_in_state $sample_proc 'T'
	return $?
}

function assert_sample_proc_sleeping()
{
	assert_task_state $sample_proc 'S'
	return $?
}

function assert_sample_proc_not_sleeping()
{
	assert_task_not_in_state $sample_proc 'S'
	return $?
}

function assert_cgroup_subsys_state_rwfile()
{
	if [ "${cgroup_subsys}" == "freezer" ]; then
		assert_cgroup_rwfile "freezer.state" "freezer state"
		return $?
	elif [ "${cgroup_subsys}" == "freezer" ]; then
		assert_cgroup_rwfile "signal.kill" "signal file"
		return $?
	else
		return -1
	fi
}

function get_freezer_state()
{
	local state="$(cat freezer.state)"
	local rc=$?

	if [ $rc -ne 0 ]; then
		result=${result:-$rc}
		tst_resm ${LIB_TEST_STATE} "Failed to read freezer state."
		return $rc
	fi
	echo "${state}"
	return 0
}

function assert_cgroup_freezer_state()
{
	local goal_state="$1"
	local state="$(get_freezer_state)"
	local rc=$?

	[ $rc -eq 0 -a "${state}" == "${goal_state}" ] && return 0
	rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected freezer state \"$2\" but found freezer state: \"$state\""
	return $rc
}

function make_sample_cgroup_named()
{
	local name="$1"
	local saved_dir="$(pwd)"
	mkdir "${name}"
	local rc=$?

	# So long as we made the directory we don't care
	if [ ! -d "${name}" -a $rc -ne 0 ]; then
		# But if it doesn't exist report the exit status of mkdir
		result=${result:-$rc}
		return $rc
	fi

	cd "${name}" > /dev/null 2>&1

	rc=$?
	if [ $rc -ne 0 ]; then
		result=${result:-$rc}
		return $rc
	fi

	assert_cgroup_tasks_rwfile || {
		cd "${saved_dir}"
		return $?
	}
	assert_cgroup_tasks_empty || {
		cd "${saved_dir}"
		return $?
	}
	assert_cgroup_subsys_state_rwfile || {
		cd "${saved_dir}"
		return $?
	}
	cd "${saved_dir}"
	return 0
}

function make_sample_cgroup()
{
	make_sample_cgroup_named "child"
	local rc=$?

	# So long as we made the directory we don't care
	if [ $rc -ne 0 ]; then
		return $rc
	fi

	cd "child" # we know this will succeed since make_sample_cgroup_named
		   # tested this
	return 0
}

function rm_sample_cgroup_named()
{
	local cgroup_name="$1"
	local saved_dir="$(pwd)"
	local rc=0

	cd "${cgroup_name}" && {
		assert_cgroup_tasks_rwfile || {
			cd "${saved_dir}"
			return $?
		}
		assert_cgroup_tasks_empty || {
			cd "${saved_dir}"
			return $?
		}
		assert_cgroup_subsys_state_rwfile || {
			cd "${saved_dir}"
			return $?
		}
		cd "${saved_dir}"
	} || {
		rc=$?
		result=${result:-$rc}
		return $rc
	}

	[ -d "${cgroup_name}" ] && rmdir "${cgroup_name}" && return 0
	rc=$?
	tst_resm TWARN "Failed to remove cgroup \"${cgroup_name}\""
	result=${result:-$rc}
	return $rc
}

function rm_sample_cgroup()
{
	local cgroup_name="$(basename $(pwd))"
	local rc=0

	cd .. || {
		rc=$?
		result=${result:-$rc}
		return $rc
	}
	rm_sample_cgroup_named "${cgroup_name}"
	return $?
}

function ls_pids()
{
	ps -e -o 'pid=' | sed -e 's/[[:space:]]\+//g'
}

function assert_task_exists()
{
	local task_pid=$1

	ls_pids | grep -E "^${task_pid}\$" > /dev/null 2>&1 && return 0
	local rc=$?

	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Expected pid ${task_pid} does not exist"
	return $rc
}

function assert_task_does_not_exist()
{
	local task_pid=$1

	ls_pids | grep -E "^${task_pid}\$" > /dev/null 2>&1 || return 0
	local rc=1 # $? == 0 is an error in this case

	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Did not expect pid ${task_pid} to exist"
	return $rc
}

function assert_sample_proc_exists()
{
	assert_task_exists $sample_proc
	return $?
}

function assert_sample_proc_does_not_exist()
{
	assert_task_does_not_exist $sample_proc
	return $rc
}

function start_sample_proc()
{
	local sample_cmd="/bin/sleep"
	local args

	args=( $sample_sleep ) # can't assign directly because of bash v2/v3 inconsistency
	if [ $# -gt 0 ]; then
		sample_cmd="$1"
		shift 1
		args=( "$@" )
	fi

	[ -n "$sample_proc" ] && assert_sample_proc_does_not_exist

	"$sample_cmd" "${args[@]}" &
	local rc=$?
	export sample_proc=$!
	assert_sample_proc_exists

	return $rc
}

function add_sample_proc_to_named_cgroup()
{
	local cgroup_name="$1"

	assert_sample_proc_exists
	"${CG_FILE_WRITE}" $sample_proc > "${cgroup_name}/tasks"
	local rc=$?
	if [ $rc -ne 0 ]; then
		result=${result:-$rc}
		tst_resm ${LIB_TEST_STATE} "Failed to add sample process $sample_proc to cgroup \"${cgroup_name}\""
		return $rc
	fi
	assert_task_in_named_cgroup $sample_proc "${cgroup_name}"
	return $?
}

function add_sample_proc_to_cgroup()
{
	add_sample_proc_to_named_cgroup "$(pwd)"
	return $?
}

function kill_sample_proc()
{
	if [ -z "$sample_proc" ]; then
		# It's no longer running or never started.
		# If it was supposed to have started but did not then that
		# should be determined by checking start_sample_proc results.
		return 0
	fi

	# Hey, bash, don't print out any of your messy job status notices
	disown -a

	if [ "$(get_task_state $sample_proc)" == "D" ]; then
		tst_resm TWARN "sample process is frozen stiff"
		kill $sample_proc
		local rc=$?
		result=${result:-$rc}
		return $rc
	fi

	# kill child processes of the sample process
	while pgrep -P $sample_proc ; do
		pkill -SIGTERM -P $sample_proc
		sleep 1
		pkill -SIGKILL -P $sample_proc

		ps -p $(pgrep -P $sample_proc) -o 'state=' | grep -v D && continue
		# Give up if all the child processes are frozen in D state or
		# if there aren't any more child processes
		break
	done
	# DEBUG dump pstree under $sample_proc:
	# pstree -A -p $sample_proc
	kill $sample_proc > /dev/null 2>&1 || kill -s SIGKILL $sample_proc > /dev/null 2>&1 || {
		local rc=$?

		ps -p $sample_proc -o 'state=' > /dev/null 2>&1
		if [ $? -eq 1 ]; then
			# It's dead. We're OK.
			return 0
		fi
		# It's still alive somehow! Give up.
		result=${result:-$rc}
		tst_resm TWARN "Failed to kill sample process $sample_proc (kill exit status: $rc)"
	}
	assert_sample_proc_not_in_cgroup
	assert_sample_proc_does_not_exist
	return $?
}

function issue_freeze_cmd()
{
	local goal_state="FROZEN"
	local sample_state_count=1
	local state="$(get_freezer_state)"
	local rc=$?

	if [ $rc -ne 0 ]; then
		return $rc
	fi

	while [ "${state}" != "${goal_state}" ]; do
		"${CG_FILE_WRITE}" "${FREEZE}" > freezer.state
		sleep $sample_state_period
		state="$(get_freezer_state)"
		rc=$?
		if [ $rc -ne 0 ]; then
			break
		fi

		((sample_state_count++))
		if [ "$sample_state_count" -ge "$max_state_samples" ]; then
			break
		fi
	done

	if [ "${state}" == "${goal_state}" ]; then
		return 0
	fi

	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Failed to issue freeze command (freezer state: \"`get_freezer_state`\")."
	return $rc
}

# If we're trying to "freeze" tasks with SIGTOP
function issue_stop_as_freeze_cmd()
{
	local goal_state="T"
	local sample_state_count=1
	local ps_state="$(get_task_state ${task_pid})"
	local rc=$?

	if [ $rc -ne 0 ]; then
		return $rc
	fi

	while [ "${ps_state}" != "${goal_state}" ]; do
		kill -s SIGSTOP $sample_proc
		sleep $sample_state_period
		ps_state="$(get_task_state ${task_pid})"
		rc=$?
		if [ $rc -ne 0 ]; then
			break
		fi

		((sample_state_count++))
		if [ "$sample_state_count" -ge "$max_state_samples" ]; then
			break
		fi
	done

	if [ "${ps_state}" == "${goal_state}" ]; then
		return 0
	fi

	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Failed to issue stop (freeze) command (task state: \"${ps_state}\")."
	return $rc
}

function send_signal()
{
	"${CG_FILE_WRITE}" $1 > 'signal.kill' && return 0
	local rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Failed to send signal: $1 to tasks in cgroup (rc: $rc)"
 	return $rc
}

function wait_until_goal_state_or_timeout()
{
	local goal_state="$1"
	local sample_state_count=1
	local state="$(get_freezer_state)"
	local rc=$?

	if [ $rc -ne 0 ]; then
		return $rc
	fi

	while [ "${state}" != "${goal_state}" ]; do
		sleep $sample_state_period
		state="$(get_freezer_state)"
		rc=$?
		if [ $rc -ne 0 ]; then
			break
		fi

		((sample_state_count++))
		if [ "$sample_state_count" -ge "$max_state_samples" ]; then
			break
		fi
	done
	return $rc
}

# TODO convert signal scripts -- insert task between until and goal
function wait_until_sample_proc_goal_state_or_timeout()
{
	local goal_state="$1"
	local sample_state_count=1
	local ps_state="$(get_task_state ${sample_proc})"
	local rc=$?

	while [ $rc -eq 0 -a "${ps_state}" != "${goal_state}" -a \
		"$sample_state_count" -lt "$max_state_samples" ]; do
		sleep $sample_state_period
		ps_state="$(get_task_state ${sample_proc})"
		rc=$?
		if [ $rc -ne 0 ]; then
			result=${result:-$rc}
			tst_resm ${LIB_TEST_STATE} "Failed to read process state."
			break
		fi

		((sample_state_count++))
	done
	return $rc
}

# TODO convert signal scripts -- insert task between until and not
function wait_until_sample_proc_not_goal_state_or_timeout()
{
	local goal_state="$1"
	local sample_state_count=1
	local ps_state="$(get_task_state ${sample_proc})"
	local rc=$?

	while [ $rc -eq 0 -a "${ps_state}" == "${goal_state}" -a \
		"$sample_state_count" -lt "$max_state_samples" ]; do
		sleep $sample_state_period
		ps_state="$(get_task_state ${sample_proc})"
		rc=$?
		if [ $rc -ne 0 ]; then
			result=${result:-$rc}
			tst_resm ${LIB_TEST_STATE} "Failed to read process state."
			break
		fi

		((sample_state_count++))
	done
	return $rc
}

function wait_until_frozen()
{
	wait_until_goal_state_or_timeout "FROZEN" || return $?
	assert_cgroup_freezer_state "FROZEN" "ERROR: failed to freeze cgroup"
	# TODO assert all tasks in cgroup are in 'D' or 'T' state
	# TODO assert that trying to add a task to cgroup results in EBUSY
	return $?
}

function issue_thaw_cmd()
{
	"${CG_FILE_WRITE}" "${THAW}" > freezer.state && return 0
	local rc=$?
	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Failed to issue thaw command."
	return $rc
}

function issue_cont_as_thaw_cmd()
{
	local goal_state="T"
	local sample_state_count=1
	local ps_state="$(get_task_state ${task_pid})"
	local rc=$?

	if [ $rc -ne 0 ]; then
		return $rc
	fi

	while [ "${ps_state}" == "${goal_state}" ]; do
		kill -s SIGCONT $sample_proc
		sleep $sample_state_period
		ps_state="$(get_task_state ${task_pid})"
		rc=$?
		if [ $rc -ne 0 ]; then
			break
		fi

		((sample_state_count++))
		if [ "$sample_state_count" -ge "$max_state_samples" ]; then
			break
		fi
	done

	if [ "${ps_state}" != "${goal_state}" ]; then
		return 0
	fi

	result=${result:-$rc}
	tst_resm ${LIB_TEST_STATE} "Failed to issue continue (thaw) command (task state: \"${ps_state}\")."
	return $rc
}

function wait_until_thawed()
{
	wait_until_goal_state_or_timeout "THAWED" || return $?
	assert_cgroup_freezer_state "THAWED" "ERROR: Failed to thaw cgroup."
	return $?
}

function wait_until_freezing()
{
	wait_until_goal_state_or_timeout "FREEZING"
	# Time critical -- we race with the kernel as it freezes tasks in the
	# cgroup. So rather than assert "FREEZING" we just return
	return $?
}

function wait_until_sample_proc_stopped()
{
	wait_until_sample_proc_state_or_timeout 'T' || return $?
	assert_sample_proc_stopped
	return $?
}

function wait_until_sample_proc_not_stopped()
{
	wait_until_sample_proc_not_goal_state_or_timeout 'T' || return $?
	assert_sample_proc_not_stopped
	return $?
}