| #!/bin/sh | |
| # | |
| # Program: RunSafely.sh | |
| # | |
| # Synopsis: This script simply runs another program. If the program works | |
| # correctly, this script has no effect, otherwise it will do things | |
| # like print a stack trace of a core dump. It always returns | |
| # "successful" so that tests will continue to be run. | |
| # | |
| # This script funnels stdout and stderr from the program into the | |
| # fourth argument specified, and outputs a <outfile>.time file which | |
| # contains a timing of the program and the program's exit code. | |
| # | |
| # If optional parameters -r <remote host> -l <remote user> are | |
| # specified, it execute the program remotely using rsh. | |
| # | |
| # Syntax: | |
| # | |
| # RunSafely.sh [-d <workdir>] [-r <rhost>] [-l <ruser>] [-rc <client>] | |
| # [-rp <port>] [-u <under>] [--show-errors] | |
| # [-n [-o <stdoutfile>] [-e <stderrfile>]] | |
| # -t <timeit> <timeout> <infile> <outfile> <program> <args...> | |
| # | |
| # where: | |
| # <workdir> is the directory where the program is executed | |
| # <rhost> is the remote host to execute the program | |
| # <ruser> is the username on the remote host | |
| # <client> is the remote client used to execute the program | |
| # <port> is the port used by the remote client | |
| # <under> is a wrapper that the program is run under | |
| # <stdoutfile> file where standard output is written to | |
| # <stderrfile> file where standard error output is written to | |
| # <timeit> is a wrapper that is used to collect timing data | |
| # <timeout> is the maximum number of seconds to let the <program> run | |
| # <infile> is a file from which standard input is directed | |
| # <outfile> is a file to which standard output and error are directed. | |
| # If -n was specified this is just used as the basename for the | |
| # .time file. | |
| # <program> is the path to the program to run | |
| # <args...> are the arguments to pass to the program. | |
| # | |
| # If --show-errors is given, then the output file will be printed if the command | |
| # fails (returns a non-zero exit code). | |
| # The -n switch will enable "new-style" output. This means the exit status is | |
| # not appended to the output anymore and stdout and stderr may be redirected | |
| # separately. | |
| # Without -n stdout and stderr will both be written to the <outfile> followed by | |
| # "exit NN" with NN being the exit status number of the program. | |
| if [ $# -lt 4 ]; then | |
| echo "./RunSafely.sh [-t <PATH>] <timeout> <infile> <outfile>" \ | |
| "<program> <args...>" | |
| exit 1 | |
| fi | |
| # Save a copy of the original arguments in a string before we | |
| # clobber them with the shift command. | |
| ORIG_ARGS="$*" | |
| DIR=${0%%`basename $0`} | |
| RHOST= | |
| RFLAGS="" | |
| RCLIENT=rsh | |
| RUN_UNDER= | |
| TIMEIT= | |
| SHOW_ERRORS=0 | |
| NEW_MODE=0 | |
| STDOUT_FILE="" | |
| STDERR_FILE="" | |
| PWD=`pwd` | |
| WORKDIR="$PWD" | |
| if [ $1 = "-d" ]; then | |
| WORKDIR="$2" | |
| shift 2 | |
| fi | |
| if [ $1 = "-r" ]; then | |
| RHOST=$2 | |
| shift 2 | |
| fi | |
| if [ $1 = "-l" ]; then | |
| RFLAGS="$RFLAGS -l $2" | |
| shift 2 | |
| fi | |
| if [ $1 = "-rc" ]; then | |
| RCLIENT=$2 | |
| shift 2 | |
| fi | |
| if [ $1 = "-rp" ]; then | |
| RFLAGS="$RFLAGS -p $2" | |
| shift 2 | |
| fi | |
| if [ $1 = "-u" ]; then | |
| RUN_UNDER=$2 | |
| shift 2 | |
| fi | |
| if [ $1 = "--show-errors" ]; then | |
| SHOW_ERRORS=1 | |
| shift 1 | |
| fi | |
| if [ $1 = "-n" ]; then | |
| NEW_MODE=1 | |
| shift 1 | |
| if [ $1 = "-o" ]; then | |
| STDOUT_FILE="$2" | |
| shift 2 | |
| fi | |
| if [ $1 = "-e" ]; then | |
| STDERR_FILE="$2" | |
| shift 2 | |
| fi | |
| fi | |
| if [ $1 = "-t" ]; then | |
| TIMEIT=$2 | |
| shift 2 | |
| fi | |
| if [ "$TIMEIT" = "" ]; then | |
| echo "error: missing required argument -t for path to 'timeit'" | |
| exit 1 | |
| fi | |
| TIMELIMIT=$1 | |
| INFILE=$2 | |
| OUTFILE=$3 | |
| PROGRAM=$4 | |
| shift 4 | |
| PROG=${PROGRAM} | |
| if [ `basename ${PROGRAM}` = "lli" ]; then | |
| PROG=`basename ${PROGRAM}` | |
| fi | |
| # Run the command, timing its execution and logging the status summary to | |
| # $OUTFILE.time. | |
| COMMAND="$RUN_UNDER $PROGRAM $*" | |
| # Determine absolute paths of infiles/outfiles | |
| INFILE="$(cd $(dirname $INFILE); pwd)/$(basename $INFILE)" | |
| if [ "$STDOUT_FILE" != "" ]; then | |
| case "$STDOUT_FILE" in | |
| /*) STDOUT_FILE="$STDOUT_FILE";; | |
| *) STDOUT_FILE="$PWD/$STDOUT_FILE";; | |
| esac | |
| fi | |
| if [ "$STDERR_FILE" != "" ]; then | |
| case "$STDERR_FILE" in | |
| /*) STDERR_FILE="$STDERR_FILE";; | |
| *) STDERR_FILE="$PWD/$STDERR_FILE";; | |
| esac | |
| fi | |
| case "$OUTFILE" in | |
| /*) OUTFILE="$OUTFILE";; | |
| *) OUTFILE="$PWD/$OUTFILE";; | |
| esac | |
| # Use suffix for remotely created files. | |
| REMOTE_SUFFIX="" | |
| if [ "x$RHOST" != x ]; then | |
| REMOTE_SUFFIX=".remote" | |
| fi | |
| # Disable core file emission. | |
| TIMEITFLAGS="" | |
| TIMEITFLAGS="$TIMEITFLAGS --limit-core 0" | |
| # Set the CPU limit. We watchdog the process, so this is mostly just for | |
| # paranoia. | |
| TIMEITFLAGS="$TIMEITFLAGS --limit-cpu $TIMELIMIT" | |
| # To prevent infinite loops which fill up the disk, specify a limit on size | |
| # of files being output by the tests. | |
| # | |
| # We set the limit at 100MB. | |
| TIMEITFLAGS="$TIMEITFLAGS --limit-file-size 104857600" | |
| # Set the virtual memory limit at 800MB. | |
| TIMEITFLAGS="$TIMEITFLAGS --limit-rss-size 838860800" | |
| TIMEITFLAGS="$TIMEITFLAGS --timeout $TIMELIMIT --chdir $WORKDIR" | |
| TIMEITFLAGS="$TIMEITFLAGS --redirect-input ${INFILE}" | |
| TIMEITFLAGS="$TIMEITFLAGS --summary ${OUTFILE}.time${REMOTE_SUFFIX}" | |
| if [ "$NEW_MODE" = "0" ]; then | |
| TIMEITFLAGS="$TIMEITFLAGS --redirect-output ${OUTFILE}${REMOTE_SUFFIX}" | |
| else | |
| if [ "$STDERR_FILE" != "" ]; then | |
| TIMEITFLAGS="$TIMEITFLAGS --redirect-stderr ${STDERR_FILE}${REMOTE_SUFFIX}" | |
| fi | |
| if [ "$STDOUT_FILE" != "" ]; then | |
| TIMEITFLAGS="$TIMEITFLAGS --redirect-stdout ${STDOUT_FILE}${REMOTE_SUFFIX}" | |
| fi | |
| fi | |
| # Run the command | |
| rm -f "${OUTFILE}.time" "${OUTFILE}" "${STDOUT_FILE}" "${STDERR_FILE}" | |
| if [ "x$RHOST" = x ] ; then | |
| $TIMEIT $TIMEITFLAGS $COMMAND | |
| else | |
| rm -f "${OUTFILE}.time${REMOTE_SUFFIX}" "${OUTFILE}${REMOTE_SUFFIX}" | |
| rm -f "${STDOUT_FILE}${REMOTE_SUFFIX}" "${STDERR_FILE}${REMOTE_SUFFIX}" | |
| # Pass LLVM_PROFILE_FILE environment variable along | |
| PREFIX="" | |
| if [ "${LLVM_PROFILE_FILE}" != "" ]; then | |
| PREFIX="LLVM_PROFILE_FILE=\"$LLVM_PROFILE_FILE\" " | |
| fi | |
| # Create .command script | |
| COMMANDFILE="${OUTFILE}.command" | |
| rm -f "${COMMANDFILE}" | |
| echo "${PREFIX}${TIMEIT} $TIMEITFLAGS $COMMAND" > "${COMMANDFILE}" | |
| chmod +x "${COMMANDFILE}" | |
| ( $RCLIENT $RFLAGS $RHOST "ls ${COMMANDFILE}" ) > /dev/null 2>&1 | |
| ( $RCLIENT $RFLAGS $RHOST "${COMMANDFILE}" ) | |
| sleep 1 | |
| # Copy remote files back | |
| cp -f "${OUTFILE}.time${REMOTE_SUFFIX}" "${OUTFILE}.time" | |
| rm -f "${OUTFILE}.time${REMOTE_SUFFIX}" | |
| if [ "$NEW_MODE" = "0" ]; then | |
| cp -f "${OUTFILE}${REMOTE_SUFFIX}" "${OUTFILE}" | |
| rm -f "${OUTFILE}${REMOTE_SUFFIX}" | |
| else | |
| if [ "$STDERR_FILE" != "" ]; then | |
| cp -f "${STDERR_FILE}${REMOTE_SUFFIX}" "${STDERR_FILE}" | |
| rm -f "${STDERR_FILE}${REMOTE_SUFFIX}" | |
| fi | |
| if [ "$STDOUT_FILE" != "" ]; then | |
| cp -f "${STDOUT_FILE}${REMOTE_SUFFIX}" "${STDOUT_FILE}" | |
| rm -f "${STDOUT_FILE}${REMOTE_SUFFIX}" | |
| fi | |
| fi | |
| fi | |
| exitval=`grep '^exit ' $OUTFILE.time | sed -e 's/^exit //'` | |
| fail=yes | |
| if [ -z "$exitval" ] ; then | |
| exitval=99 | |
| echo "TEST $PROGRAM FAILED: CAN'T GET EXIT CODE!" | |
| elif test "$exitval" -eq 126 ; then | |
| echo "TEST $PROGRAM FAILED: command not executable (exit status 126)!" | |
| elif test "$exitval" -eq 127 ; then | |
| echo "TEST $PROGRAM FAILED: command not found (exit status 127)!" | |
| elif test "$exitval" -eq 128 ; then | |
| # Exit status 128 doesn't have a standard meaning, but it's unlikely | |
| # to be expected program behavior. | |
| echo "TEST $PROGRAM FAILED: exit status 128!" | |
| elif test "$exitval" -gt 128 ; then | |
| echo "TEST $PROGRAM FAILED: process terminated by signal (exit status $exitval)!" | |
| elif [ "$SHOW_ERRORS" -eq 1 -a "$exitval" -ne 0 ] ; then | |
| echo "TEST $PROGRAM FAILED: EXIT != 0" | |
| else | |
| fail=no | |
| fi | |
| if [ "$NEW_MODE" = "0" ]; then | |
| echo "exit $exitval" >> $OUTFILE | |
| fi | |
| # If we detected a failure, print the name of the test executable to the | |
| # output file. This will cause it to compare as different with other runs | |
| # of the same test even if they fail in the same way, because they'll have | |
| # different command names. | |
| if [ "${fail}" != "no" ]; then | |
| echo "RunSafely.sh detected a failure with these command-line arguments: " \ | |
| "$ORIG_ARGS" >> $OUTFILE | |
| if [ "$SHOW_ERRORS" = "1" ]; then | |
| echo "error: command failed while generating $OUTFILE" | |
| echo "---" | |
| cat $OUTFILE | |
| echo "---" | |
| fi | |
| fi | |
| # Always return "successful" so that tests will continue to be run. | |
| exit 0 |