runltp

   1 #!/bin/sh
   2 ################################################################################
   3 ##                                                                            ##
   4 ## Copyright (c) International Business Machines  Corp., 2001                 ##
   5 ##                                                                            ##
   6 ## This program is free software;  you can redistribute it and#or modify      ##
   7 ## it under the terms of the GNU General Public License as published by       ##
   8 ## the Free Software Foundation; either version 2 of the License, or          ##
   9 ## (at your option) any later version.                                        ##
  10 ##                                                                            ##
  11 ## This program is distributed in the hope that it will be useful, but        ##
  12 ## WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY ##
  13 ## or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License   ##
  14 ## for more details.                                                          ##
  15 ##                                                                            ##
  16 ## You should have received a copy of the GNU General Public License          ##
  17 ## along with this program;  if not, write to the Free Software               ##
  18 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA    ##
  19 ##                                                                            ##
  20 ################################################################################
  21 # File: runltp
  22 #
  23 # Description:  This script can be used to the tests in the LTP test suite
  24 #
  25 # Authors:      Manoj Iyer - manjo@mail.utexas.edu
  26 #               Robbe Williamson - robbiew@us.ibm.com
  27 #
  28 # History:      Oct 07 2003 - Modified - Manoj Iyer
  29 #               - use functions
  30 #               - clean up on script exit
  31 #               - error checking etc.
  32 #
  33 #               Oct 08 2003 - Modified - Manoj Iyer
  34 #               - fixed bug in creating results directory
  35 #               - all checks should be enlclosed in " " to avoid bash error
  36 #               - exit with error if pan is not found in pan directory
  37 #
  38 #               Jul 22 2007 - Modified - Ricardo Salveti de Araujo
  39 #               - added support to put more then one file at CMDLINE (-f)
  40 #               - added a new option, that the user can pass the address of
  41 #               the command file, and it'll use wget to get it (-w)
  42 #               - now -s does the grep at the selected command files (default,
  43 #               -f or -w)
  44 #
  45 #               Jul 23 2007 - Modified - Ricardo Salveti de Araujo
  46 #               - added flag to get the command file that has all failed tests
  47 #
  48 #               Sep 11 2007 - Modified - Subrata Modak
  49 #               - added option to create Failed File if it is not an absolute path
  50 #               - added option to create Output File if it is not an absolute path
  51 #               - added option to create Failed File compulsory, even if user has not mentioned it
  52 #
  53 #               Sep 14 2007 - Modified - Ricardo Salveti de Araujo
  54 #               - cleaning and removing duplicated code
  55 #
  56 #               Oct 27 2007 - Modified - Ricardo Salveti de Araujo and Subrata Modak
  57 #               - better ways to integrate "ltp/tools/genload/stress" with "ltp/runltp"
  58 #               Nov 24 2007 - Modified - Subrata Modak
  59 #               - Added a new option to generate output in HTML format also. Also retaining
  60 #                 the original test format
  61 #               Nov 28 2007 - Modified - Subrata Modak
  62 #               - Added a new option to mail back LTP reports
  63 #               May 19 2008 - Modified - Subrata Modak
  64 #               - Added capability for default Log file generation
  65 #
  66 #################################################################################
  67
  68
  69
  70 setup()
  71 {
  72     cd `dirname $0` || \
  73     {
  74         echo "FATAL: unable to change directory to $(dirname $0)"
  75         exit 1
  76     }
  77     export LTPROOT=${PWD}
  78     export TMPBASE="/tmp"
  79     export PATH="${PATH}:${LTPROOT}/testcases/bin"
  80
  81     [ -d $LTPROOT/testcases/bin ] ||
  82     {
  83         echo "FATAL: Test suite not installed correctly"
  84         echo "INFO: as root user type 'make ; make install'"
  85         exit 1
  86     }
  87
  88     [ -e $LTPROOT/pan/pan ] ||
  89     {
  90         echo "FATAL: Test suite driver 'pan' not found"
  91         echo "INFO: as root user type 'make ; make install'"
  92         exit 1
  93     }
  94 }
  95
  96 version_of_ltp()
  97 {
  98     head -n 1  $LTPROOT/ChangeLog
  99     exit 0
 100 }
 101
 102 usage()
 103 {
 104     cat <<-EOF >&2
 105
 106     usage: ./${0##*/} [ -a EMAIL_TO ] [ -c NUM_PROCS ] [ -C FAILCMDFILE ] [ -d TMPDIR ]
 107     [ -D NUM_PROCS,NUM_FILES,NUM_BYTES,CLEAN_FLAG ] -e [ -f CMDFILES(,...) ] [ -g HTMLFILE]
 108     [ -i NUM_PROCS ] [ -l LOGFILE ] [ -m NUM_PROCS,CHUNKS,BYTES,HANGUP_FLAG ]
 109     -N -n [ -o OUTPUTFILE ] -p -q [ -r LTPROOT ] [ -s PATTERN ] [ -t DURATION ]
 110     -v [ -w CMDFILEADDR ] [ -x INSTANCES ]
 111
 112     -a EMAIL_TO     EMAIL all your Reports to this E-mail Address
 113     -c NUM_PROCS    Run LTP under additional background CPU load
 114                     [NUM_PROCS = no. of processes creating the CPU Load by spinning over sqrt()
 115                                  (Defaults to 1 when value)]
 116     -C FAILCMDFILE  Command file with all failed test cases.
 117     -d TMPDIR       Directory where temporary files will be created.
 118     -D NUM_PROCS,NUM_FILES,NUM_BYTES,CLEAN_FLAG
 119                     Run LTP under additional background Load on Secondary Storage (Seperate by comma)
 120                     [NUM_PROCS   = no. of processes creating Storage Load by spinning over write()]
 121                     [NUM_FILES   = Write() to these many files (Defaults to 1 when value 0 or undefined)]
 122                     [NUM_BYTES   = write these many bytes (defaults to 1GB, when value 0 or undefined)]
 123                     [CLEAN_FLAG  = unlink file to which random data written, when value 1]
 124     -e              Prints the date of the current LTP release
 125     -f CMDFILES     Execute user defined list of testcases (separate with ',')
 126     -g HTMLFILE     Create an additional HTML output format
 127     -h              Help. Prints all available options.
 128     -i NUM_PROCS    Run LTP under additional background Load on IO Bus
 129                     [NUM_PROCS   = no. of processes creating IO Bus Load by spinning over sync()]
 130     -l LOGFILE      Log results of test in a logfile.
 131     -m NUM_PROCS,CHUNKS,BYTES,HANGUP_FLAG
 132                     Run LTP under additional background Load on Main memory (Seperate by comma)
 133                     [NUM_PROCS   = no. of processes creating main Memory Load by spinning over malloc()]
 134                     [CHUNKS      = malloc these many chunks (default is 1 when value 0 or undefined)]
 135                     [BYTES       = malloc CHUNKS of BYTES bytes (default is 256MB when value 0 or undefined) ]
 136                     [HANGUP_FLAG = hang in a sleep loop after memory allocated, when value 1]
 137     -N              Run all the networking tests.
 138     -n              Run LTP with network traffic in background.
 139     -o OUTPUTFILE   Redirect test output to a file.
 140     -p              Human readable format logfiles.
 141     -q              Print less verbose output to screen.
 142     -r LTPROOT      Fully qualified path where testsuite is installed.
 143     -s PATTERN      Only run test cases which match PATTERN.
 144     -t DURATION     Execute the testsuite for given duration. Examples:
 145                       -t 60s = 60 seconds
 146                       -t 45m = 45 minutes
 147                       -t 24h = 24 hours
 148                       -t 2d  = 2 days
 149     -T REPETITION   Execute the testsuite for REPETITION no. of times
 150     -v              Print more verbose output to screen.
 151     -w CMDFILEADDR  Uses wget to get the user's list of testcases.
 152     -x INSTANCES    Run multiple instances of this testsuite.
 153
 154     example: ./${0##*/} -c 2 -i 2 -m 2,4,10240,1 -D 2,10,10240,1 -p -q  -l /tmp/result-log.$$ -o /tmp/result-output.$$ -C /tmp/result-failed.$$ -d ${PWD}
 155
 156
 157         EOF
 158 exit 0
 159 }
 160
 161 main()
 162 {
 163     local CMDFILES=""
 164     local PRETTY_PRT=""
 165     local ALT_DIR_OUT=0
 166     local ALT_DIR_RES=0
 167     local ALT_HTML_OUT=0
 168     local ALT_EMAIL_OUT=0
 169     local RUN_NETEST=0
 170     local RUN_REPEATED=0
 171     local QUIET_MODE=""
 172     local VERBOSE_MODE=""
 173     local NETPIPE=0
 174     local GENLOAD=0
 175     local MEMSIZE=0
 176     local DURATION=""
 177     local CMDFILEADDR=""
 178     local FAILCMDFILE=""
 179     local LOGFILE_NAME=""
 180     local LOGFILE=""
 181     local OUTPUTFILE_NAME=""
 182     local OUTPUTFILE=""
 183     local HTMLFILE_NAME=""
 184     local HTMLFILE=""
 185     local EMAIL_TO=""
 186     local SCENFILES=""
 187     local TAG_RESTRICT_STRING=""
 188     local PAN_COMMAND=""
 189     local DEFAULT_FILE_NAME_GENERATION_TIME=`date +"%Y_%b_%d-%Hh_%Mm_%Ss"`
 190     version_date=`head -n 1 $LTPROOT/ChangeLog`
 191
 192     while getopts a:c:C:d:D:f:ehi:g:l:m:Nno:pqr:s:t:T:vw:x: arg
 193     do  case $arg in
 194         a)  EMAIL_TO=$OPTARG
 195             ALT_EMAIL_OUT=1;;
 196         c)
 197             NUM_PROCS=$(($OPTARG))
 198             if   [ "$NUM_PROCS" -eq 0 ]; then
 199                 # User Did not Define the Value ,or, User Defined Zero,
 200                 # hence, prevent from creating infinite processes
 201                 NUM_PROCS=1
 202             fi
 203             $LTPROOT/testcases/bin/genload --cpu $NUM_PROCS >/dev/null 2>&1 &
 204             GENLOAD=1 ;;
 205
 206         C)
 207             case $OPTARG in
 208             /*)
 209                 FAILCMDFILE="-C $OPTARG" ;;
 210             *)
 211                 FAILCMDFILE="-C $LTPROOT/output/$OPTARG"
 212                 ALT_DIR_OUT=1 ;;
 213             esac ;;
 214
 215         d)  # convert the user path to absolute path.
 216             export TMPBASE=`cd \`dirname ${OPTARG}\`; pwd`/`basename ${OPTARG}` ;;
 217
 218         D)  NUM_PROCS=1; NUM_FILES=1; NUM_BYTES=$((1024 * 1024 * 1024)); CLEAN_FLAG=0
 219             ARGUMENT_LIST=$OPTARG
 220             TOTAL_ARGUMENTS=1                                             # Initial Assume
 221             for ARGUMENT in `echo "$ARGUMENT_LIST" | sed 's/,/\n/g'`      # Store all value in a Loop
 222             do
 223                 case $TOTAL_ARGUMENTS in
 224                     1) NUM_PROCS="$ARGUMENT" ;;
 225                     2) NUM_FILES="$ARGUMENT" ;;
 226                     3) NUM_BYTES="$ARGUMENT" ;;
 227                     4) CLEAN_FLAG="$ARGUMENT" ;;
 228                 esac
 229                 TOTAL_ARGUMENTS=`expr $TOTAL_ARGUMENTS + 1`
 230             done
 231             # just to get the default values if the user passed 0
 232             if [ "$NUM_PROCS" -eq 0 ]; then
 233                 NUM_PROCS=1
 234             fi
 235             if [ "$NUM_FILES" -eq 0 ]; then
 236                 NUM_FILES=1
 237             fi
 238             if [ "$NUM_BYTES" -eq 0 ]; then
 239                 NUM_BYTES=$((1024 * 1024 * 1024))
 240             fi
 241             if [ "$CLEAN_FLAG" -ne 1 ]; then
 242                 CLEAN_FLAG=0
 243             fi
 244             if [ "$CLEAN_FLAG" -eq 1 ]; then
 245                 # Do not unlink file in this case
 246                 $LTPROOT/testcases/bin/genload --hdd $NUM_PROCS --hdd-files \
 247                     $NUM_FILES --hdd-bytes $NUM_BYTES >/dev/null 2>&1 &
 248             else
 249                 # Cleanup otherwise
 250                 $LTPROOT/testcases/bin/genload --hdd $NUM_PROCS --hdd-files \
 251                     $NUM_FILES --hdd-bytes $NUM_BYTES --hdd-noclean >/dev/null 2>&1 &
 252             fi
 253             GENLOAD=1;;
 254
 255         e)  # Print out the version of LTP
 256             version_of_ltp
 257             ;;
 258         f)  # Execute user defined set of testcases.
 259             # Can be more then one file, just separate it with ',', like:
 260             # -f nfs,commands,/tmp/testfile
 261             CMDFILES=$OPTARG;;
 262         g)  HTMLFILE_NAME="$OPTARG"
 263             case $OPTARG in
 264             /*)
 265                 HTMLFILE="$OPTARG";;
 266             *)
 267                 HTMLFILE="$LTPROOT/output/$OPTARG";;
 268             esac
 269             ALT_DIR_OUT=1
 270             ALT_HTML_OUT=1;;
 271         h)  usage;;
 272
 273         i)
 274             NUM_PROCS=$(($OPTARG))
 275             if   [ "$NUM_PROCS" -eq 0 ]; then
 276                 # User Did not Define the Value ,or, User Defined Zero,
 277                 # hence, prevent from creating infinite processes
 278                 NUM_PROCS=1
 279             fi
 280             $LTPROOT/testcases/bin/genload --io $NUM_PROCS >/dev/null 2>&1 &
 281             GENLOAD=1 ;;
 282
 283         l)
 284             LOGFILE_NAME="$OPTARG"
 285             case $OPTARG in
 286             /*)
 287                 LOGFILE="-l $OPTARG" ;;
 288             *)
 289                 LOGFILE="-l $LTPROOT/results/$OPTARG"
 290                 ALT_DIR_RES=1 ;;
 291             esac ;;
 292
 293         m)  NUM_PROCS=1; CHUNKS=1; BYTES=$((256 * 1024 * 1024)); HANGUP_FLAG=0
 294             ARGUMENT_LIST=$OPTARG
 295             TOTAL_ARGUMENTS=1                                             # Initial Assume
 296             for ARGUMENT in `echo "$ARGUMENT_LIST" | sed 's/,/\n/g'`      # Store all value in a Loop
 297             do
 298                 case $TOTAL_ARGUMENTS in
 299                     1) NUM_PROCS="$ARGUMENT" ;;
 300                     2) CHUNKS="$ARGUMENT" ;;
 301                     3) BYTES="$ARGUMENT" ;;
 302                     4) HANGUP_FLAG="$ARGUMENT" ;;
 303                 esac
 304                 TOTAL_ARGUMENTS=`expr $TOTAL_ARGUMENTS + 1`
 305             done
 306             # just to get the default values if the user passed 0
 307             if [ "$NUM_PROCS" -eq 0 ]; then
 308                 NUM_PROCS=1
 309             fi
 310             if [ "$CHUNKS" -eq 0 ]; then
 311                 CHUNKS=1
 312             fi
 313             if [ "$BYTES" -eq 0 ]; then
 314                 BYTES=$((256 * 1024 * 1024))
 315             fi
 316             if [ "$HANGUP_FLAG" -ne 1 ]; then
 317                 HANGUP_FLAG=0
 318             fi
 319             if [ "$HANGUP_FLAG" -eq 1 ]; then
 320                 # Hang in a Sleep loop after memory allocated
 321                 $LTPROOT/testcases/bin/genload --vm $NUM_PROCS --vm-chunks \
 322                     $CHUNKS --vm-bytes $BYTES --vm-hang >/dev/null 2>&1 &
 323             else
 324                 # Otherwise Do not Hangup
 325                 $LTPROOT/testcases/bin/genload --vm $NUM_PROCS --vm-chunks \
 326                     $CHUNKS --vm-bytes $BYTES >/dev/null 2>&1 &
 327             fi
 328             GENLOAD=1;;
 329
 330         N)  RUN_NETEST=1;;
 331
 332         n)
 333             $LTPROOT/testcases/bin/netpipe.sh
 334             NETPIPE=1;;
 335
 336         o)  OUTPUTFILE_NAME="$OPTARG"
 337             case $OPTARG in
 338             /*)
 339                 OUTPUTFILE="-o $OPTARG";;
 340             *)
 341                 OUTPUTFILE="-o $LTPROOT/output/$OPTARG"
 342                 ALT_DIR_OUT=1 ;;
 343             esac ;;
 344
 345         p)  PRETTY_PRT=" -p ";;
 346
 347         q)  QUIET_MODE=" -q ";;
 348
 349         r)  LTPROOT=$OPTARG;;
 350
 351         s)  TAG_RESTRICT_STRING=$OPTARG;;
 352
 353         t)  # In case you want to specify the time
 354             # to run from the command line
 355             # (2m = two minutes, 2h = two hours, etc)
 356             DURATION="-t $OPTARG" ;;
 357
 358         T)  # In case you want the testcases to runsequentially RUN_REPEATED times
 359             RUN_REPEATED=$OPTARG;;
 360
 361         v)  VERBOSE_MODE=1;;
 362
 363         w)  CMDFILEADDR=$OPTARG;;
 364
 365         x)  # number of ltp's to run
 366             cat <<-EOF >&1
 367             WARNING: The use of -x can cause unpredictable failures, as a
 368                      result of concurrently running multiple tests designed
 369                      to be ran exclusively.
 370                      Pausing for 10 seconds..."
 371         EOF
 372             sleep 10
 373             INSTANCES="-x $OPTARG";;
 374
 375         \?) usage;;
 376         esac
 377     done
 378
 379     ## It would be nice to create a default log file even if the user has not mentioned
 380     if [ ! "$LOGFILE" ]; then                                ## User has not mentioned about Log File name
 381        LOGFILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 382        LOGFILE="-l $LTPROOT/results/LTP_RUN_ON-$LOGFILE_NAME.log"
 383        ALT_DIR_RES=1
 384        PRETTY_PRT=" -p "
 385     fi
 386
 387     ## It would be nice if a Failed File is compulsorily created (gives User better Idea of Tests that failed)
 388
 389     if [ ! "$FAILCMDFILE" ]; then                            ## User has not mentioned about Failed File name
 390          ALT_DIR_OUT=1
 391          if [ ! "$OUTPUTFILE" ]; then                        ## User has not mentioned about Output File name either
 392             if [ ! "$LOGFILE" ]; then                        ## User has not mentioned about Log File name either
 393                FAILED_FILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 394                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 395             else                                             ## User Fortunately wanted a log file,
 396                FAILED_FILE_NAME=`basename $LOGFILE_NAME`     ## Extract log file name and use it to construct Failed file name
 397                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 398             fi
 399          else                                                ## User Fortunately wanted a Output file
 400                FAILED_FILE_NAME=`basename $OUTPUTFILE_NAME`  ## Extract output file name and use it to construct Failed file name
 401                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 402          fi
 403     fi
 404
 405     if [ "$ALT_HTML_OUT" -eq 1 ] ; then                      ## User wants the HTML version of the output
 406        QUIET_MODE=""                                         ## Suppressing this guy as it will prevent generation of proper output
 407                                                              ## which the HTML parser will require
 408        if [ ! "$OUTPUTFILE" ]; then                          ## User has not mentioned about the Outputfile name, then we need to definitely generate one
 409           OUTPUTFILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 410           OUTPUTFILE="-o $LTPROOT/output/LTP_RUN_ON-$OUTPUTFILE_NAME.output"
 411           ALT_DIR_OUT=1
 412           if [ ! "$HTMLFILE" ] ; then                        ## User has not mentioned HTML File name, We need to create one
 413              HTMLFILE_NAME=`basename $OUTPUTFILE_NAME`
 414              HTMLFILE="$LTPROOT/output/$HTMLFILE_NAME.html"
 415           fi
 416        fi
 417     fi
 418
 419     # If we need, create the output directory
 420     [ "$ALT_DIR_OUT" -eq 1 ] && \
 421     {
 422         echo "INFO: creating $LTPROOT/output directory"
 423         [ ! -d $LTPROOT/output ] && \
 424         {
 425            mkdir -p $LTPROOT/output || \
 426            {
 427                echo "ERROR: failed to create $LTPROOT/output"
 428                exit 1
 429             }
 430         }
 431     }
 432     # If we need, create the results directory
 433     [ "$ALT_DIR_RES" -eq 1 ] && \
 434     {
 435         echo "INFO: creating $LTPROOT/results directory"
 436         [ ! -d $LTPROOT/results ] && \
 437         {
 438            mkdir -p $LTPROOT/results || \
 439            {
 440                echo "ERROR: failed to create $LTPROOT/results"
 441                exit 1
 442             }
 443         }
 444     }
 445
 446     # Added -m 777 for tests that call tst_tmpdir() and try to
 447     #  write to it as user nobody
 448     mkdir -m 777 -p $TMPBASE || \
 449     {
 450         echo "FATAL: Unable to make temporary directory $TMPBASE"
 451         exit 1
 452     }
 453     # use mktemp to create "safe" temporary directories
 454     export TMPTEMPLATE="${TMPBASE}/ltp-XXXXXXXXXX"
 455     TMP=`mktemp -d $TMPTEMPLATE` || \
 456     {
 457         echo "FATAL: Unable to make temporary directory: $TMP"
 458         exit 1
 459     }
 460     export TMP
 461     # To be evoked by tst_tmpdir()
 462     #  write to it as user nobody
 463     export TMPDIR="/tmp"
 464
 465     chmod 777 $TMP || \
 466     {
 467       echo "unable to chmod 777 $TMP ... aborting"
 468         exit 1
 469     }
 470
 471     cd $TMP || \
 472     {
 473       echo "could not cd ${TMP} ... exiting"
 474       exit 1
 475     }
 476
 477     ! [ -z $INSTANCES ] && \
 478     {
 479             INSTANCES="$INSTANCES -O ${TMP}"
 480     }
 481
 482     [ "$RUN_NETEST" -eq 1 ] && \
 483     {
 484         [ -z "$RHOST" ] || [ -z "$PASSWD" ] && \
 485         {
 486             [ -z "$RHOST" ] && \
 487             {
 488                 echo \
 489                 "INFO: Enter RHOST = 'name of the remote host machine'"
 490                 echo -n "-> "
 491                 read RHOST
 492             }
 493
 494             [ -z "$PASSWD" ] && \
 495             {
 496                 echo " "
 497                 echo \
 498                 "INFO: Enter PASSWD = 'root passwd of the remote host machine'"
 499                 echo -n "-> "
 500                 read PASSWD
 501             }
 502             export RHOST=$RHOST
 503             export PASSWD=$PASSWD
 504             echo "WARNING: security of $RHOST may be compromised"
 505         }
 506     }
 507
 508     # If user does not provide a command file select a default set of testcases
 509     # to execute.
 510     if [ -z "$CMDFILES" ] && [ -z "$CMDFILEADDR" ]
 511     then
 512         cat <<-EOF >&1
 513
 514     INFO: no command files were provided, using default,
 515           system calls, memory management, IPC, scheduler
 516           direct io, file system, math and pty tests will
 517           now be executed
 518
 519         EOF
 520
 521         for SCENFILES in ${LTPROOT}/runtest/syscalls                \
 522                          ${LTPROOT}/runtest/fs                      \
 523                          ${LTPROOT}/runtest/fsx                     \
 524                          ${LTPROOT}/runtest/dio                     \
 525                          ${LTPROOT}/runtest/mm                      \
 526                          ${LTPROOT}/runtest/ipc                     \
 527                          ${LTPROOT}/runtest/sched                   \
 528                          ${LTPROOT}/runtest/math                    \
 529                          ${LTPROOT}/runtest/nptl                    \
 530                          ${LTPROOT}/runtest/pty                     \
 531                          ${LTPROOT}/runtest/containers              \
 532                          ${LTPROOT}/runtest/fs_bind                 \
 533                          ${LTPROOT}/runtest/controllers             \
 534                          ${LTPROOT}/runtest/filecaps                \
 535                          ${LTPROOT}/runtest/fcntl-locktests         \
 536                          ${LTPROOT}/runtest/connectors              \
 537                          ${LTPROOT}/runtest/admin_tools             \
 538                          ${LTPROOT}/runtest/timers                  \
 539                          ${LTPROOT}/runtest/power_management_tests  \
 540                          ${LTPROOT}/runtest/numa                    \
 541                          ${LTPROOT}/runtest/hugetlb                 \
 542                          ${LTPROOT}/runtest/commands
 543         do
 544             [ -e "$SCENFILES" ] || \
 545             {
 546                 echo "FATAL: missing scenario file $SCENFILES"
 547                 exit 1
 548             }
 549
 550             cat $SCENFILES >> ${TMP}/alltests || \
 551             {
 552                 echo "FATAL: unable to create command file"
 553                 exit 1
 554             }
 555        done
 556     fi
 557
 558     [ -n "$CMDFILES" ] && \
 559     {
 560         for SCENFILES in `echo "$CMDFILES" | sed 's/,/\n/g'`
 561         do
 562             [ -f "$SCENFILES" ] || SCENFILES="$LTPROOT/runtest/$SCENFILES"
 563             cat "$SCENFILES" >> ${TMP}/alltests || \
 564             {
 565                 echo "FATAL: unable to create command file"
 566                 exit 1
 567             }
 568         done
 569     }
 570
 571     [ -n "$CMDFILEADDR" ] && \
 572     {
 573         wget -q "${CMDFILEADDR}" -O ${TMP}/wgetcmdfile
 574         if [ $? -ne 0 ]; then
 575             echo "FATAL: error while getting the command file with wget (address $CMDFILEADDR)"
 576             exit 1
 577         fi
 578         cat "${TMP}/wgetcmdfile" >> ${TMP}/alltests || \
 579         {
 580             echo "FATAL: unable to create command file"
 581             exit 1
 582         }
 583     }
 584
 585     [ "$RUN_NETEST" -eq 1 ] && \
 586     {
 587         for SCENFILES in ${LTPROOT}/runtest/tcp_cmds \
 588                          ${LTPROOT}/runtest/multicast \
 589                          ${LTPROOT}/runtest/rpc \
 590                          ${LTPROOT}/runtest/nfs
 591         do
 592             [ -e "$SCENFILES" ] || \
 593             {
 594                 echo "FATAL: missing scenario file $SCENFILES"
 595                 exit 1
 596             }
 597
 598             cat "$SCENFILES" >> ${TMP}/alltests || \
 599             {
 600                 echo "FATAL: unable to create command file"
 601                 exit 1
 602             }
 603         done
 604     }
 605
 606     # The fsx-linux tests use the SCRATCHDEV environment variable as a location
 607     # that can be reformatted and run on.  Set SCRATCHDEV if you want to run
 608     # these tests.  As a safeguard, this is disabled.
 609     unset SCRATCHDEV
 610     [ -n "$SCRATCHDEV" ] && \
 611     {
 612          cat ${LTPROOT}/runtest/fsx >> ${TMP}/alltests ||
 613          {
 614              echo "FATAL: unable to create  fsx-linux tests command file"
 615              exit 1
 616          }
 617     }
 618
 619     # If enabled, execute only test cases that match the PATTERN
 620     if [ -n "$TAG_RESTRICT_STRING" ]
 621     then
 622         mv -f ${TMP}/alltests ${TMP}/alltests.orig
 623             grep $TAG_RESTRICT_STRING ${TMP}/alltests.orig > ${TMP}/alltests #Not worth checking return codes for this case
 624     fi
 625
 626     # check for required users and groups
 627     ${LTPROOT}/IDcheck.sh &>/dev/null || \
 628     {
 629         echo "WARNING: required users and groups not present"
 630         echo "WARNING: some test cases may fail"
 631     }
 632
 633     # display versions of installed software
 634     [ -z "$QUIET_MODE" ] && \
 635     {
 636         ${LTPROOT}/ver_linux || \
 637         {
 638             echo "WARNING: unable to display versions of software installed"
 639             exit 1
 640     }
 641     }
 642
 643     if [ $RUN_REPEATED -gt 1 ]; then # You need to specify at least more than 1 sequential run, else it runs default
 644          echo "PAN will run these test cases $RUN_REPEATED times....."
 645          echo "Test Tags will be Prepended with ITERATION NO.s....."
 646          inc=1
 647          sed -e '/^$/ d' -e 's/^[ ,\t]*//' -e '/^#/ d' < ${TMP}/alltests > ${TMP}/alltests.temp ##This removes all newlines, leading spaces, tabs, #
 648          sed 's/^[0-9,a-z,A-Z]*/'"$inc"'_ITERATION_&/' < ${TMP}/alltests.temp > ${TMP}/alltests ## .temp is kept as Base file
 649          while [ $inc -lt $RUN_REPEATED ] ; do
 650                inc=`expr $inc + 1`
 651                sed 's/^[0-9,a-z,A-Z]*/'"$inc"'_ITERATION_&/' < ${TMP}/alltests.temp >> ${TMP}/alltests #Keep appending with Iteration No.s
 652          done
 653     fi
 654
 655     [ ! -z "$QUIET_MODE" ] && { echo "INFO: Test start time: $(date)" ; }
 656     PAN_COMMAND="${LTPROOT}/pan/pan $QUIET_MODE -e -S $INSTANCES $DURATION -a $$ \
 657     -n $$ $PRETTY_PRT -f ${TMP}/alltests $LOGFILE $OUTPUTFILE $FAILCMDFILE"
 658     if [ ! -z "$VERBOSE_MODE" ] ; then
 659       echo "COMMAND:    $PAN_COMMAND"
 660       if [ ! -z "$TAG_RESTRICT_STRING" ] ; then
 661         echo "INFO: Restricted to $TAG_RESTRICT_STRING"
 662       fi
 663     fi
 664     #$PAN_COMMAND #Duplicated code here, because otherwise if we fail, only "PAN_COMMAND" gets output
 665
 666     ## Display the Output/Log/Failed/HTML file names here
 667     echo -e "LOG File: \c"
 668     echo $LOGFILE | cut -b4-
 669
 670     if [ "$OUTPUTFILE" ]; then
 671        echo -e "OUTPUT File: \c"
 672        echo $OUTPUTFILE | cut -b4-
 673     fi
 674
 675     echo -e "FAILED COMMAND File: \c"
 676     echo $FAILCMDFILE | cut -b4-
 677
 678     if [ "$HTMLFILE" ]; then
 679        echo "HTML File: $HTMLFILE"
 680     fi
 681
 682     echo "Running tests......."
 683     test_start_time=$(date)
 684     ${LTPROOT}/pan/pan $QUIET_MODE -e -S $INSTANCES $DURATION -a $$ -n $$ $PRETTY_PRT -f ${TMP}/alltests $LOGFILE $OUTPUTFILE $FAILCMDFILE
 685
 686     if [ $? -eq 0 ]; then
 687       echo "INFO: pan reported all tests PASS"
 688       VALUE=0
 689       export LTP_EXIT_VALUE=0;
 690     else
 691       echo "INFO: pan reported some tests FAIL"
 692       VALUE=1
 693       export LTP_EXIT_VALUE=1;
 694     fi
 695     echo "LTP Version: $version_date"
 696
 697     if [ "$ALT_HTML_OUT" -eq 1 ] ; then        #User wants the HTML output to be created, it then needs to be generated
 698        export LTP_VERSION=$version_date
 699        export TEST_START_TIME=$test_start_time
 700        export TEST_END_TIME=$(date)
 701        OUTPUT_DIRECTORY=`echo $OUTPUTFILE | cut -c4-`
 702        LOGS_DIRECTORY="$LTPROOT/results"
 703        export TEST_OUTPUT_DIRECTORY="$LTPROOT/output"
 704        export TEST_LOGS_DIRECTORY=$LOGS_DIRECTORY
 705        echo "Generating HTML Output.....!!"
 706        ( perl $LTPROOT/tools/genhtml.pl $LTPROOT/tools/html_report_header.txt test_start test_end test_output execution_status $OUTPUT_DIRECTORY  > $HTMLFILE; )
 707        echo "Generated HTML Output.....!!"
 708        echo "Location: $HTMLFILE";
 709
 710     fi
 711
 712     if [ "$ALT_EMAIL_OUT" -eq 1 ] ; then                      ## User wants reports to be e-mailed
 713        if [ [ ! "$HTMLFILE_NAME" ] -o [ ! "$OUTPUTFILE_NAME" ] -o [ ! "$LOGFILE_NAME" ] ] ; then
 714           ##User does not have output/logs/html-output, nothing to be mailed in this situation
 715           echo "Nothing to be mailed here...."
 716        else
 717            TAR_FILE_NAME=LTP_RUN_$version_date$DEFAULT_FILE_NAME_GENERATION_TIME.tar
 718            if [ "$HTMLFILE_NAME" ] ; then                          ## HTML file Exists
 719               if [ "$ALT_HTML_OUT" -ne 1 ] ; then                  ## The HTML file path is absolute and not $LTPROOT/output
 720                  mkdir -p $LTPROOT/output                          ## We need to create this Directory
 721                  cp $HTMLFILE_NAME $LTPROOT/output/
 722               fi
 723            fi
 724            if [ "$OUTPUTFILE_NAME" ] ; then                        ## Output file exists
 725               if [ "$ALT_DIR_OUT" -ne 1 ] ; then                   ## The Output file path is absolute and not $LTPROOT/output
 726                  mkdir -p $LTPROOT/output                          ## We need to create this Directory
 727                  cp $OUTPUTFILE_NAME $LTPROOT/output/
 728               fi
 729            fi
 730            if [ "$LOGFILE_NAME" ] ; then                           ## Log file exists
 731               if [ "$ALT_DIR_RES" -ne 1 ] ; then                   ## The Log file path is absolute and not $LTPROOT/results
 732                  mkdir -p $LTPROOT/results                         ## We need to create this Directory
 733                  cp $LOGFILE_NAME $LTPROOT/results/
 734               fi
 735            fi
 736            if [ -d $LTPROOT/output ] ; then
 737               tar -cf  ./$TAR_FILE_NAME $LTPROOT/output
 738               if [ $? -eq 0 ]; then
 739                  echo "Created TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/output"
 740               else
 741                  echo "Cannot Create TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/output"
 742               fi
 743            fi
 744            if [ -d $LTPROOT/results ] ; then
 745               tar -uf ./$TAR_FILE_NAME $LTPROOT/results
 746               if [ $? -eq 0 ]; then
 747                  echo "Updated TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/results"
 748               else
 749                  echo "Cannot Update TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/results"
 750               fi
 751            fi
 752            if [ -e $LTPROOT/nohup.out ] ; then                     ## If User would have Chosen nohup to do ltprun
 753               tar -uf ./$TAR_FILE_NAME $LTPROOT/nohup.out
 754               if [ $? -eq 0 ]; then
 755                  echo "Updated TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/nohup.out"
 756               else
 757                  echo "Cannot Update TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/nohup.out"
 758               fi
 759            fi
 760            gzip ./$TAR_FILE_NAME                                     ## gzip this guy
 761            if [ $? -eq 0 ]; then
 762               echo "Gunzipped TAR File: ./$TAR_FILE_NAME"
 763            else
 764               echo "Cannot Gunzip TAR File: ./$TAR_FILE_NAME"
 765            fi
 766            if [ -e /usr/bin/mutt ] ; then                          ## This is a better mail client than others
 767               echo "Starting mailing reports to: $EMAIL_TO, file: ./$TAR_FILE_NAME.gz"
 768               mutt -a ./$TAR_FILE_NAME.gz -s "LTP Reports on $test_start_time" $EMAIL_TO < /dev/null
 769               if [ $? -eq 0 ]; then
 770                  echo "Reports Successfully mailed to: $EMAIL_TO"
 771               else
 772                  echo "Reports cannot be mailed to: $EMAIL_TO"
 773               fi
 774            else ## Use our Ageold mail program
 775               echo "Starting mailing reports to: $EMAIL_TO, file: ./$TAR_FILE_NAME.gz"
 776               uuencode ./$TAR_FILE_NAME.gz $TAR_FILE_NAME.gz | mail  $EMAIL_TO -s "LTP Reports on $test_start_time"
 777               if [ $? -eq 0 ]; then
 778                  echo "Reports Successfully mailed to: $EMAIL_TO"
 779               else
 780                  echo "Reports cannot be mailed to: $EMAIL_TO"
 781               fi
 782            fi
 783        fi
 784     fi
 785
 786     [ ! -z "$QUIET_MODE" ] && { echo "INFO: Test end time: $(date)" ; }
 787
 788     [ "$GENLOAD" -eq 1 ] && { killall -9 genload  >/dev/null 2>&1; }
 789     [ "$NETPIPE" -eq 1 ] && { killall -9 NPtcp  >/dev/null 2>&1; }
 790
 791     [ "$ALT_DIR_OUT" -eq 1 ] || [ "$ALT_DIR_RES" -eq 1 ] && \
 792     {
 793     cat <<-EOF >&1
 794
 795        ###############################################################"
 796
 797             Done executing testcases."
 798             LTP Version:  $version_date
 799        ###############################################################"
 800
 801         EOF
 802     }
 803     exit $VALUE
 804 }
 805
 806 cleanup()
 807 {
 808     rm -rf ${TMP}
 809 }
 810
 811 trap "cleanup" 0
 812 setup
 813 main "$@"