# process exec tests.

# value gets set later
set test_exepath ""

# "load" generation function for stap_run.  It spawns our test
# executable, which execs our copy of /bin/sleep.
proc run_test_exe {} {
    global test_exepath
    global exepath

    spawn $test_exepath $exepath
    set exe_id $spawn_id
    after 5000
    catch {close -i $exe_id}
    catch {wait -i $exe_id}
    return 0;
}

# Set up our own copy of /bin/sleep, to make testing for a particular
# executable easy.  We can't use 'ln' here, since we might be creating
# a cross-device link.  We can't use 'ln -s' here, since the kernel
# resolves the symbolic link and reports that /bin/sleep is being
# exec'ed (instead of our local copy).
set exepath "[pwd]/sleep_[pid]"
if {[catch {exec cp /bin/sleep $exepath} res]} {
    fail "unable to copy /bin/sleep: $res"
    return
}

# Note use of '%1$s' - the 'N$' is the 'argpos', the argument position
# passed to 'format'.
set test_script {
    global output
    global sleep_start, sleep_end
    probe begin { printf("systemtap starting probe\n") }
    probe process("%1$s").begin {
	output .= sprintf("exe(%%d) begin\n", tid())
    }
    probe process("%1$s").thread.begin {
	output .= sprintf("exe(%%d) thread begin\n", tid())
    }
    probe process("%1$s").end {
	output .= sprintf("exe(%%d) end\n", tid())
    }
    probe process("%1$s").thread.end {
	output .= sprintf("exe(%%d) thread end\n", tid())
    }
    probe process("%2$s").begin {
	sleep_start = gettimeofday_s()
	output .= sprintf("sleep(%%d) begin\n", tid())
    }
    probe process("%2$s").end {
	output .= sprintf("sleep(%%d) end\n", tid())
	sleep_end = gettimeofday_s()
    }
    probe end {
	printf("systemtap ending probe\n%%s", output)
	time_slept = sleep_end - sleep_start
	if (time_slept >= 2 && time_slept <= 4)
	    printf("time slept: OK\n")
	else
	    printf("time slept: ERROR (%%d)\n", time_slept)
    }
}

#######
#
# Test a normal fork/exec pair.
#

set fork_exec_srcpath "$srcdir/systemtap.base/proc_fork_exec.c"
set fork_exec_exepath "[pwd]/proc_fork_exec_[pid]"
set fork_exec_flags ""

# We make sure the outputs looks like the following using regexp
# subexpressions:
#	exe(PARENT_PID) begin
#	exe(CHILD_PID) begin
#	exe(CHILD_PID) end
#	sleep(CHILD_PID) begin
#	sleep(CHILD_PID) end
#	exe(PARENT_PID) end
#	time slept: OK
#
# Accept the 'sleep(CHILD_PID)' end and 'exe(PARENT_PID) end' lines in
# any order.
set fork_exec_script_output "exe\\((\\d+)\\) begin\r\nexe\\((\\d+)\\) begin\r\nexe\\(\\2\\) end\r\nsleep\\(\\2\\) begin\r\n(sleep\\(\\2\\)|exe\\(\\1\\)) end\r\n(sleep\\(\\2\\)|exe\\(\\1\\)) end\r\ntime slept: OK\r\n"

# Compile our program that forks/exec's /bin/sleep.
set test_exepath $fork_exec_exepath
set res [target_compile $fork_exec_srcpath $fork_exec_exepath executable $fork_exec_flags]
if { $res != "" } {
    verbose "target_compile failed: $res" 2
    fail "unable to compile $fork_exec_srcpath"
    return
}

set TEST_NAME "PROC_EXEC_01"
if {![utrace_p]} {
    untested "$TEST_NAME : no kernel utrace support found"
} elseif {![installtest_p]} {
    untested "$TEST_NAME"
} else {
    set script [format $test_script $fork_exec_exepath $exepath]
    stap_run $TEST_NAME run_test_exe $fork_exec_script_output -e $script
}

#######
#
# Test a straight exec (no fork).
#

set exec_srcpath "$srcdir/systemtap.base/proc_exec.c"
set exec_exepath "[pwd]/proc_exec_[pid]"
set exec_flags ""

# We make sure the outputs looks like the following using regexp
# subexpressions:
#	exe(PID) begin
#	exe(PID) end
#	sleep(PID) begin
#	sleep(PID) end
#	time slept: OK
set exec_script_output "exe\\((\\d+)\\) begin\r\nexe\\(\\1\\) end\r\nsleep\\(\\1\\) begin\r\nsleep\\(\\1\\) end\r\ntime slept: OK\r\n"

# Compile our program that exec's /bin/sleep.
set test_exepath $exec_exepath
set res [target_compile $exec_srcpath $exec_exepath executable $exec_flags]
if { $res != "" } {
    verbose "target_compile failed: $res" 2
    fail "unable to compile $exec_srcpath"
    return
}

set TEST_NAME "PROC_EXEC_02"
if {![utrace_p]} {
    untested "$TEST_NAME : no kernel utrace support found"
} elseif {![installtest_p]} {
    untested "$TEST_NAME"
} else {
    set script [format $test_script $exec_exepath $exepath]
    stap_run $TEST_NAME run_test_exe $exec_script_output -e $script
}

#######
#
# Test a multi-threaded exec, which programs aren't supposed to do,
# but...
#

set thread_exec_srcpath "$srcdir/systemtap.base/proc_thread_exec.c"
set thread_exec_exepath "[pwd]/proc_thread_exec_[pid]"
set thread_exec_flags "libs=-lpthread"

# We make sure the outputs looks like the following using regexp
# subexpressions.
#	exe(PID1) begin
#	exe(PID2) thread begin
#	exe(PID1) thread end
#	exe(PID1) end
#	sleep(PID1) begin
#	sleep(PID1) end
#	time slept: OK
#
# Why no PID2 thread end and why isn't sleep using PID2?  When the
# thread calls exec (which it isn't supposed to do), the kernel has to
# clean up the best it can.  It really kills the original task,
# promotes the thread to be the process group leader (and changes the
# thread's pid to the original process group leader's pid).
set thread_exec_script_output "exe\\((\\d+)\\) begin\r\nexe\\(\\d+\\) thread begin\r\nexe\\(\\1\\)( thread)? end\r\nexe\\(\\1\\) end\r\nsleep\\(\\1\\) begin\r\nsleep\\(\\1\\) end\r\ntime slept: OK\r\n"

# Compile our multi-threaded program that exec's /bin/sleep.
set test_exepath $thread_exec_exepath
set res [target_compile $thread_exec_srcpath $thread_exec_exepath executable $thread_exec_flags]
if { $res != "" } {
    verbose "target_compile failed: $res" 2
    fail "unable to compile $exec_srcpath"
    return
}

set TEST_NAME "PROC_EXEC_03"
if {![utrace_p]} {
    untested "$TEST_NAME : no kernel utrace support found"
} elseif {![installtest_p]} {
    untested "$TEST_NAME"
} else {
    set script [format $test_script $thread_exec_exepath $exepath]
    stap_run $TEST_NAME run_test_exe $thread_exec_script_output -e $script
}

# Cleanup
exec rm -f $exepath $fork_exec_exepath $exec_exepath $thread_exec_exepath
