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 ltp-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 #               Aug 17 2009 - Modified - Subrata Modak
  66 #               - Added Fault Injection generation Capability through -F Option
  67 #
  68 #################################################################################
  69
  70
  71
  72 setup()
  73 {
  74     cd `dirname $0` || \
  75     {
  76         echo "FATAL: unable to change directory to $(dirname $0)"
  77         exit 1
  78     }
  79     export LTPROOT=${PWD}
  80     export TMPBASE="/tmp"
  81     export PATH="${PATH}:${LTPROOT}/testcases/bin"
  82
  83     [ -d "$LTPROOT/testcases/bin" ] ||
  84     {
  85         echo "FATAL: Test suite not installed correctly"
  86         echo "INFO: as root user type 'make ; make install'"
  87         exit 1
  88     }
  89
  90     [ -e "$LTPROOT/bin/ltp-pan" ] ||
  91     {
  92         echo "FATAL: Test suite driver 'ltp-pan' not found"
  93         echo "INFO: as root user type 'make ; make install'"
  94         exit 1
  95     }
  96 }
  97
  98 version_of_ltp()
  99 {
 100     cat "$LTPROOT/Version"
 101     exit 0
 102 }
 103
 104 usage()
 105 {
 106     cat <<-EOF >&2
 107
 108     usage: ./${0##*/} [ -a EMAIL_TO ] [ -c NUM_PROCS ] [ -C FAILCMDFILE ] [ -d TMPDIR ]
 109     [ -D NUM_PROCS,NUM_FILES,NUM_BYTES,CLEAN_FLAG ] -e [ -f CMDFILES(,...) ] [ -g HTMLFILE]
 110     [ -i NUM_PROCS ] [ -l LOGFILE ] [ -m NUM_PROCS,CHUNKS,BYTES,HANGUP_FLAG ]
 111     -N -n [ -o OUTPUTFILE ] -p -q [ -r LTPROOT ] [ -s PATTERN ] [ -t DURATION ]
 112     -v [ -w CMDFILEADDR ] [ -x INSTANCES ] [ -b DEVICE ] [-B DEVICE_FS_TYPE]
 113         [ -F LOOPS,PERCENTAGE ]
 114
 115     -a EMAIL_TO     EMAIL all your Reports to this E-mail Address
 116     -c NUM_PROCS    Run LTP under additional background CPU load
 117                     [NUM_PROCS = no. of processes creating the CPU Load by spinning over sqrt()
 118                                  (Defaults to 1 when value)]
 119     -C FAILCMDFILE  Command file with all failed test cases.
 120     -d TMPDIR       Directory where temporary files will be created.
 121     -D NUM_PROCS,NUM_FILES,NUM_BYTES,CLEAN_FLAG
 122                     Run LTP under additional background Load on Secondary Storage (Seperate by comma)
 123                     [NUM_PROCS   = no. of processes creating Storage Load by spinning over write()]
 124                     [NUM_FILES   = Write() to these many files (Defaults to 1 when value 0 or undefined)]
 125                     [NUM_BYTES   = write these many bytes (defaults to 1GB, when value 0 or undefined)]
 126                     [CLEAN_FLAG  = unlink file to which random data written, when value 1]
 127     -e              Prints the date of the current LTP release
 128     -f CMDFILES     Execute user defined list of testcases (separate with ',')
 129         -F LOOPS,PERCENTAGE Induce PERCENTAGE Fault in the Kernel Subsystems, and, run each test for LOOPS loop
 130     -g HTMLFILE     Create an additional HTML output format
 131     -h              Help. Prints all available options.
 132     -i NUM_PROCS    Run LTP under additional background Load on IO Bus
 133                     [NUM_PROCS   = no. of processes creating IO Bus Load by spinning over sync()]
 134     -l LOGFILE      Log results of test in a logfile.
 135     -m NUM_PROCS,CHUNKS,BYTES,HANGUP_FLAG
 136                     Run LTP under additional background Load on Main memory (Seperate by comma)
 137                     [NUM_PROCS   = no. of processes creating main Memory Load by spinning over malloc()]
 138                     [CHUNKS      = malloc these many chunks (default is 1 when value 0 or undefined)]
 139                     [BYTES       = malloc CHUNKS of BYTES bytes (default is 256MB when value 0 or undefined) ]
 140                     [HANGUP_FLAG = hang in a sleep loop after memory allocated, when value 1]
 141         -M CHECK_TYPE
 142                 [CHECK_TYPE=1 => Full Memory Leak Check tracing children as well]
 143                 [CHECK_TYPE=2 => Thread Concurrency Check tracing children as well]
 144                 [CHECK_TYPE=3 => Full Memory Leak & Thread Concurrency Check tracing children as well]
 145     -N              Run all the networking tests.
 146     -n              Run LTP with network traffic in background.
 147     -o OUTPUTFILE   Redirect test output to a file.
 148     -p              Human readable format logfiles.
 149     -q              Print less verbose output to screen.
 150     -r LTPROOT      Fully qualified path where testsuite is installed.
 151     -s PATTERN      Only run test cases which match PATTERN.
 152     -S SKIPFILE     Skip tests specified in SKIPFILE
 153     -t DURATION     Execute the testsuite for given duration. Examples:
 154                       -t 60s = 60 seconds
 155                       -t 45m = 45 minutes
 156                       -t 24h = 24 hours
 157                       -t 2d  = 2 days
 158     -T REPETITION   Execute the testsuite for REPETITION no. of times
 159     -w CMDFILEADDR  Uses wget to get the user's list of testcases.
 160     -x INSTANCES    Run multiple instances of this testsuite.
 161     -b DEVICE       Some tests require an unmounted block device
 162                     to run correctly.
 163     -B DEVICE_FS_TYPE The file system of test block devices.
 164
 165
 166     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}
 167
 168
 169         EOF
 170 exit 0
 171 }
 172
 173 main()
 174 {
 175     local CMDFILES=""
 176     local PRETTY_PRT=""
 177     local ALT_DIR_OUT=0
 178     local ALT_DIR_RES=0
 179     local ALT_HTML_OUT=0
 180     local ALT_EMAIL_OUT=0
 181     local RUN_NETEST=0
 182     local RUN_REPEATED=0
 183     local QUIET_MODE=""
 184     local NETPIPE=0
 185     local GENLOAD=0
 186     local MEMSIZE=0
 187     local DURATION=""
 188     local CMDFILEADDR=""
 189     local FAILCMDFILE=""
 190     local INJECT_KERNEL_FAULT=""
 191     local INJECT_KERNEL_FAULT_PERCENTAGE=""
 192     local INJECT_FAULT_LOOPS_PER_TEST=""
 193     local VALGRIND_CHECK=""
 194     local VALGRIND_CHECK_TYPE=""
 195     local LOGFILE_NAME=""
 196     local LOGFILE=""
 197     local OUTPUTFILE_NAME=""
 198     local OUTPUTFILE=""
 199     local HTMLFILE_NAME=""
 200     local HTMLFILE=""
 201     local EMAIL_TO=""
 202     local SCENFILES=""
 203     local TAG_RESTRICT_STRING=""
 204     local PAN_COMMAND=""
 205     local DEFAULT_FILE_NAME_GENERATION_TIME=`date +"%Y_%b_%d-%Hh_%Mm_%Ss"`
 206     version_date=$(cat "$LTPROOT/Version")
 207
 208     while getopts a:c:C:d:D:f:F:ehi:g:l:m:M:Nno:pqr:s:S:t:T:w:x:b:B: arg
 209     do  case $arg in
 210         a)  EMAIL_TO=$OPTARG
 211             ALT_EMAIL_OUT=1;;
 212         c)
 213             NUM_PROCS=$(($OPTARG))
 214             if   [ "$NUM_PROCS" -eq 0 ]; then
 215                 # User Did not Define the Value ,or, User Defined Zero,
 216                 # hence, prevent from creating infinite processes
 217                 NUM_PROCS=1
 218             fi
 219             $LTPROOT/testcases/bin/genload --cpu $NUM_PROCS >/dev/null 2>&1 &
 220             GENLOAD=1 ;;
 221
 222         C)
 223             case $OPTARG in
 224             /*)
 225                 FAILCMDFILE="-C $OPTARG" ;;
 226             *)
 227                 FAILCMDFILE="-C $LTPROOT/output/$OPTARG"
 228                 ALT_DIR_OUT=1 ;;
 229             esac ;;
 230
 231         d)  # convert the user path to absolute path.
 232             export TMPBASE=`cd \`dirname ${OPTARG}\`; pwd`/`basename ${OPTARG}` ;;
 233
 234         D)  NUM_PROCS=1; NUM_FILES=1; NUM_BYTES=$((1024 * 1024 * 1024)); CLEAN_FLAG=0
 235             ARGUMENT_LIST=$OPTARG
 236             TOTAL_ARGUMENTS=1                                             # Initial Assume
 237             for ARGUMENT in `echo "$ARGUMENT_LIST" | sed 's/,/\n/g'`      # Store all value in a Loop
 238             do
 239                 case $TOTAL_ARGUMENTS in
 240                     1) NUM_PROCS="$ARGUMENT" ;;
 241                     2) NUM_FILES="$ARGUMENT" ;;
 242                     3) NUM_BYTES="$ARGUMENT" ;;
 243                     4) CLEAN_FLAG="$ARGUMENT" ;;
 244                 esac
 245                 TOTAL_ARGUMENTS=`expr $TOTAL_ARGUMENTS + 1`
 246             done
 247             # just to get the default values if the user passed 0
 248             if [ "$NUM_PROCS" -eq 0 ]; then
 249                 NUM_PROCS=1
 250             fi
 251             if [ "$NUM_FILES" -eq 0 ]; then
 252                 NUM_FILES=1
 253             fi
 254             if [ "$NUM_BYTES" -eq 0 ]; then
 255                 NUM_BYTES=$((1024 * 1024 * 1024))
 256             fi
 257             if [ "$CLEAN_FLAG" -ne 1 ]; then
 258                 CLEAN_FLAG=0
 259             fi
 260             if [ "$CLEAN_FLAG" -eq 1 ]; then
 261                 # Do not unlink file in this case
 262                 $LTPROOT/testcases/bin/genload --hdd $NUM_PROCS --hdd-files \
 263                     $NUM_FILES --hdd-bytes $NUM_BYTES >/dev/null 2>&1 &
 264             else
 265                 # Cleanup otherwise
 266                 $LTPROOT/testcases/bin/genload --hdd $NUM_PROCS --hdd-files \
 267                     $NUM_FILES --hdd-bytes $NUM_BYTES --hdd-noclean >/dev/null 2>&1 &
 268             fi
 269             GENLOAD=1;;
 270
 271         e)  # Print out the version of LTP
 272             version_of_ltp
 273             ;;
 274         f)  # Execute user defined set of testcases.
 275             # Can be more then one file, just separate it with ',', like:
 276             # -f nfs,commands,/tmp/testfile
 277             CMDFILES=$OPTARG;;
 278         F)      INJECT_KERNEL_FAULT=1
 279                 #Seperate out the NO_OF_LOOPS & FAULT_PERCENTAGE
 280                 INJECT_FAULT_LOOPS_PER_TEST=`echo $OPTARG |cut -d',' -f1 | tr -d '\n' | tr -d ' '`
 281                 INJECT_KERNEL_FAULT_PERCENTAGE=`echo $OPTARG |cut -d',' -f2 | tr -d '\n' | tr -d ' '`
 282                 if [ ! $INJECT_FAULT_LOOPS_PER_TEST ]; then
 283                         echo "Loops not properly defined. Resorting to default 5..."
 284                         export INJECT_FAULT_LOOPS_PER_TEST=5
 285                 fi
 286                 if [ ! $INJECT_KERNEL_FAULT_PERCENTAGE ]; then
 287                         echo "Fault Persentage not properly defined. Resorting to default 10..."
 288                         export INJECT_KERNEL_FAULT_PERCENTAGE=10
 289                 fi;;
 290         g)  HTMLFILE_NAME="$OPTARG"
 291             case $OPTARG in
 292             /*)
 293                 HTMLFILE="$OPTARG";;
 294             *)
 295                 HTMLFILE="$LTPROOT/output/$OPTARG";;
 296             esac
 297             ALT_DIR_OUT=1
 298             ALT_HTML_OUT=1;;
 299         h)  usage;;
 300
 301         i)
 302             NUM_PROCS=$(($OPTARG))
 303             if   [ "$NUM_PROCS" -eq 0 ]; then
 304                 # User Did not Define the Value ,or, User Defined Zero,
 305                 # hence, prevent from creating infinite processes
 306                 NUM_PROCS=1
 307             fi
 308             $LTPROOT/testcases/bin/genload --io $NUM_PROCS >/dev/null 2>&1 &
 309             GENLOAD=1 ;;
 310
 311         l)
 312             LOGFILE_NAME="$OPTARG"
 313             case $OPTARG in
 314             /*)
 315                 LOGFILE="-l $OPTARG" ;;
 316             *)
 317                 LOGFILE="-l $LTPROOT/results/$OPTARG"
 318                 ALT_DIR_RES=1 ;;
 319             esac ;;
 320
 321         m)  NUM_PROCS=1; CHUNKS=1; BYTES=$((256 * 1024 * 1024)); HANGUP_FLAG=0
 322             ARGUMENT_LIST=$OPTARG
 323             TOTAL_ARGUMENTS=1                                             # Initial Assume
 324             for ARGUMENT in `echo "$ARGUMENT_LIST" | sed 's/,/\n/g'`      # Store all value in a Loop
 325             do
 326                 case $TOTAL_ARGUMENTS in
 327                     1) NUM_PROCS="$ARGUMENT" ;;
 328                     2) CHUNKS="$ARGUMENT" ;;
 329                     3) BYTES="$ARGUMENT" ;;
 330                     4) HANGUP_FLAG="$ARGUMENT" ;;
 331                 esac
 332                 TOTAL_ARGUMENTS=`expr $TOTAL_ARGUMENTS + 1`
 333             done
 334             # just to get the default values if the user passed 0
 335             if [ "$NUM_PROCS" -eq 0 ]; then
 336                 NUM_PROCS=1
 337             fi
 338             if [ "$CHUNKS" -eq 0 ]; then
 339                 CHUNKS=1
 340             fi
 341             if [ "$BYTES" -eq 0 ]; then
 342                 BYTES=$((256 * 1024 * 1024))
 343             fi
 344             if [ "$HANGUP_FLAG" -ne 1 ]; then
 345                 HANGUP_FLAG=0
 346             fi
 347             if [ "$HANGUP_FLAG" -eq 1 ]; then
 348                 # Hang in a Sleep loop after memory allocated
 349                 $LTPROOT/testcases/bin/genload --vm $NUM_PROCS --vm-chunks \
 350                     $CHUNKS --vm-bytes $BYTES --vm-hang >/dev/null 2>&1 &
 351             else
 352                 # Otherwise Do not Hangup
 353                 $LTPROOT/testcases/bin/genload --vm $NUM_PROCS --vm-chunks \
 354                     $CHUNKS --vm-bytes $BYTES >/dev/null 2>&1 &
 355             fi
 356             GENLOAD=1;;
 357         M)
 358                 VALGRIND_CHECK=1
 359                 VALGRIND_CHECK_TYPE="$OPTARG";;
 360
 361         N)  RUN_NETEST=1;;
 362
 363         n)
 364             $LTPROOT/testcases/bin/netpipe.sh
 365             NETPIPE=1;;
 366
 367         o)  OUTPUTFILE_NAME="$OPTARG"
 368             case $OPTARG in
 369             /*)
 370                 OUTPUTFILE="-o $OPTARG";;
 371             *)
 372                 OUTPUTFILE="-o $LTPROOT/output/$OPTARG"
 373                 ALT_DIR_OUT=1 ;;
 374             esac ;;
 375
 376         p)  PRETTY_PRT=" -p ";;
 377
 378         q)  QUIET_MODE=" -q ";;
 379
 380         r)  LTPROOT=$OPTARG;;
 381
 382         s)  TAG_RESTRICT_STRING=$OPTARG;;
 383
 384         S)  case $OPTARG in
 385             /*)
 386                 SKIPFILE=$OPTARG;;
 387             *)
 388                 SKIPFILE="$LTPROOT/$OPTARG";;
 389             esac ;;
 390
 391         t)  # In case you want to specify the time
 392             # to run from the command line
 393             # (2m = two minutes, 2h = two hours, etc)
 394             DURATION="-t $OPTARG" ;;
 395
 396         T)  # In case you want the testcases to runsequentially RUN_REPEATED times
 397             RUN_REPEATED=$OPTARG;;
 398
 399         w)  CMDFILEADDR=$OPTARG;;
 400
 401         x)  # number of ltp's to run
 402             cat <<-EOF >&1
 403             WARNING: The use of -x can cause unpredictable failures, as a
 404                      result of concurrently running multiple tests designed
 405                      to be ran exclusively.
 406                      Pausing for 10 seconds..."
 407         EOF
 408             sleep 10
 409             INSTANCES="-x $OPTARG";;
 410         b) DEVICE=$OPTARG;;
 411         B) DEVICE_FS_TYPE=$OPTARG;;
 412         \?) usage;;
 413         esac
 414     done
 415
 416     ## It would be nice to create a default log file even if the user has not mentioned
 417     if [ ! "$LOGFILE" ]; then                                ## User has not mentioned about Log File name
 418        LOGFILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 419        LOGFILE="-l $LTPROOT/results/LTP_RUN_ON-$LOGFILE_NAME.log"
 420        ALT_DIR_RES=1
 421        PRETTY_PRT=" -p "
 422     fi
 423
 424     ## It would be nice if a Failed File is compulsorily created (gives User better Idea of Tests that failed)
 425
 426     if [ ! "$FAILCMDFILE" ]; then                            ## User has not mentioned about Failed File name
 427          ALT_DIR_OUT=1
 428          if [ ! "$OUTPUTFILE" ]; then                        ## User has not mentioned about Output File name either
 429             if [ ! "$LOGFILE" ]; then                        ## User has not mentioned about Log File name either
 430                FAILED_FILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 431                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 432             else                                             ## User Fortunately wanted a log file,
 433                FAILED_FILE_NAME=`basename $LOGFILE_NAME`     ## Extract log file name and use it to construct Failed file name
 434                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 435             fi
 436          else                                                ## User Fortunately wanted a Output file
 437                FAILED_FILE_NAME=`basename $OUTPUTFILE_NAME`  ## Extract output file name and use it to construct Failed file name
 438                FAILCMDFILE="-C $LTPROOT/output/LTP_RUN_ON-$FAILED_FILE_NAME.failed"
 439          fi
 440     fi
 441
 442     if [ "$ALT_HTML_OUT" -eq 1 ] ; then                      ## User wants the HTML version of the output
 443        QUIET_MODE=""                                         ## Suppressing this guy as it will prevent generation of proper output
 444                                                              ## which the HTML parser will require
 445        if [ ! "$OUTPUTFILE" ]; then                          ## User has not mentioned about the Outputfile name, then we need to definitely generate one
 446           OUTPUTFILE_NAME=$DEFAULT_FILE_NAME_GENERATION_TIME
 447           OUTPUTFILE="-o $LTPROOT/output/LTP_RUN_ON-$OUTPUTFILE_NAME.output"
 448           ALT_DIR_OUT=1
 449           if [ ! "$HTMLFILE" ] ; then                        ## User has not mentioned HTML File name, We need to create one
 450              HTMLFILE_NAME=`basename $OUTPUTFILE_NAME`
 451              HTMLFILE="$LTPROOT/output/$HTMLFILE_NAME.html"
 452           fi
 453        fi
 454     fi
 455
 456     # If we need, create the output directory
 457     [ "$ALT_DIR_OUT" -eq 1 ] && \
 458     {
 459         [ ! -d $LTPROOT/output ] && \
 460         {
 461            echo "INFO: creating $LTPROOT/output directory"
 462            mkdir -p $LTPROOT/output || \
 463            {
 464                echo "ERROR: failed to create $LTPROOT/output"
 465                exit 1
 466             }
 467         }
 468     }
 469     # If we need, create the results directory
 470     [ "$ALT_DIR_RES" -eq 1 ] && \
 471     {
 472         echo "INFO: creating $LTPROOT/results directory"
 473         [ ! -d $LTPROOT/results ] && \
 474         {
 475            mkdir -p $LTPROOT/results || \
 476            {
 477                echo "ERROR: failed to create $LTPROOT/results"
 478                exit 1
 479             }
 480         }
 481     }
 482
 483     # Added -m 777 for tests that call tst_tmpdir() and try to
 484     #  write to it as user nobody
 485     mkdir -m 777 -p $TMPBASE || \
 486     {
 487         echo "FATAL: Unable to make temporary directory $TMPBASE"
 488         exit 1
 489     }
 490     # use mktemp to create "safe" temporary directories
 491     export TMPTEMPLATE="${TMPBASE}/ltp-XXXXXXXXXX"
 492     TMP=`mktemp -d $TMPTEMPLATE` || \
 493     {
 494         echo "FATAL: Unable to make temporary directory: $TMP"
 495         exit 1
 496     }
 497     export TMP
 498     # To be invoked by tst_tmpdir()
 499     # write to it as user nobody
 500     export TMPDIR=$TMP
 501
 502     chmod 777 $TMP || \
 503     {
 504       echo "unable to chmod 777 $TMP ... aborting"
 505         exit 1
 506     }
 507
 508     cd $TMP || \
 509     {
 510       echo "could not cd ${TMP} ... exiting"
 511       exit 1
 512     }
 513
 514     ! [ -z $INSTANCES ] && \
 515     {
 516             INSTANCES="$INSTANCES -O ${TMP}"
 517     }
 518
 519     [ "$RUN_NETEST" -eq 1 ] && \
 520     {
 521         [ -z "$RHOST" ] || [ -z "$PASSWD" ] && \
 522         {
 523             [ -z "$RHOST" ] && \
 524             {
 525                 echo \
 526                 "INFO: Enter RHOST = 'name of the remote host machine'"
 527                 echo -n "-> "
 528                 read RHOST
 529             }
 530
 531             [ -z "$PASSWD" ] && \
 532             {
 533                 echo " "
 534                 echo \
 535                 "INFO: Enter PASSWD = 'root passwd of the remote host machine'"
 536                 echo -n "-> "
 537                 read PASSWD
 538             }
 539             export RHOST=$RHOST
 540             export PASSWD=$PASSWD
 541             echo "WARNING: security of $RHOST may be compromised"
 542         }
 543     }
 544
 545     # If user does not provide a command file select a default set of testcases
 546     # to execute.
 547     if [ -z "$CMDFILES" ] && [ -z "$CMDFILEADDR" ]
 548     then
 549         cat <<-EOF >&1
 550
 551     INFO: no command files were provided, using default,
 552           system calls, memory management, IPC, scheduler
 553           direct io, file system, math and pty tests will
 554           now be executed
 555
 556         EOF
 557
 558         for SCENFILES in ${LTPROOT}/runtest/syscalls                \
 559                          ${LTPROOT}/runtest/fs                      \
 560                          ${LTPROOT}/runtest/fsx                     \
 561                          ${LTPROOT}/runtest/dio                     \
 562                          ${LTPROOT}/runtest/io                      \
 563                          ${LTPROOT}/runtest/mm                      \
 564                          ${LTPROOT}/runtest/ipc                     \
 565                          ${LTPROOT}/runtest/sched                   \
 566                          ${LTPROOT}/runtest/math                    \
 567                          ${LTPROOT}/runtest/nptl                    \
 568                          ${LTPROOT}/runtest/pty                     \
 569                          ${LTPROOT}/runtest/containers              \
 570                          ${LTPROOT}/runtest/fs_bind                 \
 571                          ${LTPROOT}/runtest/controllers             \
 572                          ${LTPROOT}/runtest/filecaps                \
 573                          ${LTPROOT}/runtest/cap_bounds              \
 574                          ${LTPROOT}/runtest/fcntl-locktests         \
 575                          ${LTPROOT}/runtest/connectors              \
 576                          ${LTPROOT}/runtest/admin_tools             \
 577                          ${LTPROOT}/runtest/timers                  \
 578                          ${LTPROOT}/runtest/power_management_tests  \
 579                          ${LTPROOT}/runtest/numa                    \
 580                          ${LTPROOT}/runtest/hugetlb                 \
 581                          ${LTPROOT}/runtest/commands                \
 582                          ${LTPROOT}/runtest/hyperthreading
 583         do
 584             [ -e "$SCENFILES" ] || \
 585             {
 586                 echo "FATAL: missing scenario file $SCENFILES"
 587                 exit 1
 588             }
 589
 590             cat $SCENFILES >> ${TMP}/alltests || \
 591             {
 592                 echo "FATAL: unable to create command file"
 593                 exit 1
 594             }
 595        done
 596     fi
 597
 598     [ -n "$CMDFILES" ] && \
 599     {
 600         for SCENFILES in `echo "$CMDFILES" | sed 's/,/\n/g'`
 601         do
 602             [ -f "$SCENFILES" ] || SCENFILES="$LTPROOT/runtest/$SCENFILES"
 603             cat "$SCENFILES" >> ${TMP}/alltests || \
 604             {
 605                 echo "FATAL: unable to create command file"
 606                 exit 1
 607             }
 608         done
 609     }
 610
 611     [ -n "$CMDFILEADDR" ] && \
 612     {
 613         wget -q "${CMDFILEADDR}" -O ${TMP}/wgetcmdfile
 614         if [ $? -ne 0 ]; then
 615             echo "FATAL: error while getting the command file with wget (address $CMDFILEADDR)"
 616             exit 1
 617         fi
 618         cat "${TMP}/wgetcmdfile" >> ${TMP}/alltests || \
 619         {
 620             echo "FATAL: unable to create command file"
 621             exit 1
 622         }
 623     }
 624
 625     [ "$RUN_NETEST" -eq 1 ] && \
 626     {
 627         for SCENFILES in ${LTPROOT}/runtest/tcp_cmds \
 628                          ${LTPROOT}/runtest/multicast \
 629                          ${LTPROOT}/runtest/rpc \
 630                          ${LTPROOT}/runtest/nfs
 631         do
 632             [ -e "$SCENFILES" ] || \
 633             {
 634                 echo "FATAL: missing scenario file $SCENFILES"
 635                 exit 1
 636             }
 637
 638             cat "$SCENFILES" >> ${TMP}/alltests || \
 639             {
 640                 echo "FATAL: unable to create command file"
 641                 exit 1
 642             }
 643         done
 644     }
 645
 646     # The fsx-linux tests use the SCRATCHDEV environment variable as a location
 647     # that can be reformatted and run on.  Set SCRATCHDEV if you want to run
 648     # these tests.  As a safeguard, this is disabled.
 649     unset SCRATCHDEV
 650     [ -n "$SCRATCHDEV" ] && \
 651     {
 652          cat ${LTPROOT}/runtest/fsx >> ${TMP}/alltests ||
 653          {
 654              echo "FATAL: unable to create  fsx-linux tests command file"
 655              exit 1
 656          }
 657     }
 658
 659     # If enabled, execute only test cases that match the PATTERN
 660     if [ -n "$TAG_RESTRICT_STRING" ]
 661     then
 662         mv -f ${TMP}/alltests ${TMP}/alltests.orig
 663             grep $TAG_RESTRICT_STRING ${TMP}/alltests.orig > ${TMP}/alltests #Not worth checking return codes for this case
 664     fi
 665
 666     # Blacklist or skip tests if a SKIPFILE was specified with -S
 667     if [ -n "$SKIPFILE" ]
 668     then
 669         for file in $( cat $SKIPFILE ); do
 670             sed -i "/$file/d" ${TMP}/alltests
 671         done
 672     fi
 673
 674     # check for required users and groups
 675     ${LTPROOT}/IDcheck.sh &>/dev/null || \
 676     {
 677         echo "WARNING: required users and groups not present"
 678         echo "WARNING: some test cases may fail"
 679     }
 680
 681     # display versions of installed software
 682     [ -z "$QUIET_MODE" ] && \
 683     {
 684         ${LTPROOT}/ver_linux || \
 685         {
 686             echo "WARNING: unable to display versions of software installed"
 687             exit 1
 688     }
 689     }
 690
 691     if [ -n "$DEVICE" ]; then
 692         sed -i "s|DEVICE|$DEVICE|"  ${TMP}/alltests
 693     else
 694         echo "remove test cases which require the block device."
 695     echo "You can specify it with option -b"
 696         sed -i "/DEVICE/d"  ${TMP}/alltests
 697     fi
 698
 699     if [ $? -ne 0 ]; then
 700             echo "FATAL: error during prcessing alltests file by sed"
 701             exit 1
 702     fi
 703
 704     if [ -n "$DEVICE" ]; then
 705         mnt_pnt=`mktemp -d --tmpdir=${TMP} mnt_pnt.XXXXXX`
 706         if [ -n "$DEVICE_FS_TYPE" ]; then
 707             mount -t $DEVICE_FS_TYPE $DEVICE $mnt_pnt
 708         else
 709             mount $DEVICE $mnt_pnt
 710         fi
 711
 712         if [ $? -ne 0 ]; then
 713             echo "FATAL: can't mount block device $DEVICE."
 714             exit 1
 715         fi
 716
 717         if [ -z "$DEVICE_FS_TYPE" ]; then
 718             DEVICE_FS_TYPE=`cat /proc/mounts | awk "{if (\\\$1 == \"$DEVICE\") print \\\$3; }"`
 719             echo "determine file system $DEVICE_FS_TYPE on block device $DEVICE"
 720         fi
 721
 722         umount $DEVICE
 723         if [ $? -ne 0 ]; then
 724             echo "FATAL: can't umount $DEVICE"
 725             exit 1
 726         fi
 727         rm -rf $mnt_pnt
 728     fi
 729
 730     if [ -n "$DEVICE" ]; then
 731         sed -i "s|DEVICE_FS_TYPE|$DEVICE_FS_TYPE|"  ${TMP}/alltests
 732     fi
 733
 734     if [ $? -ne 0 ]; then
 735         echo "FATAL: error during prcessing alltests file by sed"
 736         exit 1
 737     fi
 738
 739     if [ $RUN_REPEATED -gt 1 ]; then # You need to specify at least more than 1 sequential run, else it runs default
 740          echo "PAN will run these test cases $RUN_REPEATED times....."
 741          echo "Test Tags will be Prepended with ITERATION NO.s....."
 742          inc=1
 743          sed -e '/^$/ d' -e 's/^[ ,\t]*//' -e '/^#/ d' < ${TMP}/alltests > ${TMP}/alltests.temp ##This removes all newlines, leading spaces, tabs, #
 744          sed 's/^[0-9,a-z,A-Z]*/'"$inc"'_ITERATION_&/' < ${TMP}/alltests.temp > ${TMP}/alltests ## .temp is kept as Base file
 745          while [ $inc -lt $RUN_REPEATED ] ; do
 746                inc=`expr $inc + 1`
 747                sed 's/^[0-9,a-z,A-Z]*/'"$inc"'_ITERATION_&/' < ${TMP}/alltests.temp >> ${TMP}/alltests #Keep appending with Iteration No.s
 748          done
 749     fi
 750
 751     [ ! -z "$QUIET_MODE" ] && { echo "INFO: Test start time: $(date)" ; }
 752     PAN_COMMAND="${LTPROOT}/bin/ltp-pan $QUIET_MODE -e -S $INSTANCES $DURATION -a $$ \
 753     -n $$ $PRETTY_PRT -f ${TMP}/alltests $LOGFILE $OUTPUTFILE $FAILCMDFILE"
 754     echo "COMMAND:    $PAN_COMMAND"
 755     if [ ! -z "$TAG_RESTRICT_STRING" ] ; then
 756       echo "INFO: Restricted to $TAG_RESTRICT_STRING"
 757     fi
 758     #$PAN_COMMAND #Duplicated code here, because otherwise if we fail, only "PAN_COMMAND" gets output
 759
 760     ## Display the Output/Log/Failed/HTML file names here
 761     echo -e "LOG File: \c"
 762     echo $LOGFILE | cut -b4-
 763
 764     if [ "$OUTPUTFILE" ]; then
 765        echo -e "OUTPUT File: \c"
 766        echo $OUTPUTFILE | cut -b4-
 767     fi
 768
 769     echo -e "FAILED COMMAND File: \c"
 770     echo $FAILCMDFILE | cut -b4-
 771
 772     if [ "$HTMLFILE" ]; then
 773        echo "HTML File: $HTMLFILE"
 774     fi
 775
 776     echo "Running tests......."
 777     test_start_time=$(date)
 778
 779         # User wants testing with Kernel Fault Injection
 780         if [ $INJECT_KERNEL_FAULT ] ; then
 781                 #See if Debugfs is mounted, and
 782                 #Fault Injection Framework available through Debugfs
 783                 if [ -d "/sys/kernel/debug/fail_io_timeout" -o \
 784                         -d "/sys/kernel/debug/fail_make_request" -o \
 785                         -d "/sys/kernel/debug/fail_page_alloc" -o \
 786                         -d "/sys/kernel/debug/failslab" ]; then
 787                         #If atleast one of the Framework is available
 788                         #Go ahead to Inject Fault & Create required
 789                         #Command Files for LTP run
 790                         echo Running tests with Fault Injection Enabled in the Kernel...
 791                         ${LTPROOT}/tools/create_kernel_faults_in_loops_and_probability.pl\
 792                                 ${TMP}/alltests $INJECT_FAULT_LOOPS_PER_TEST $INJECT_KERNEL_FAULT_PERCENTAGE > ${TMP}/alltests.tmp
 793                         cp ${TMP}/alltests.tmp ${TMP}/alltests
 794                         rm -rf ${TMP}/alltests.tmp
 795                 else
 796                         echo Fault Injection not enabled in the Kernel..
 797                         echo Running tests normally...
 798                 fi
 799         fi
 800
 801         ## Valgrind Check will work only when Kernel Fault Injection is not expected,
 802         ## We do not want to test Faults when valgrind is running
 803         if [ $VALGRIND_CHECK ]; then
 804                 if [ ! $INJECT_KERNEL_FAULT ]; then
 805                         which valgrind || VALGRIND_CHECK_TYPE=XYZ
 806                         case $VALGRIND_CHECK_TYPE in
 807                                 1)
 808                                 ${LTPROOT}/tools/create_valgrind_check.pl ${TMP}/alltests 1 > ${TMP}/alltests.tmp
 809                                 cp ${TMP}/alltests.tmp ${TMP}/alltests
 810                                 rm -rf ${TMP}/alltests.tmp;;
 811                                 2)
 812                                 ${LTPROOT}/tools/create_valgrind_check.pl ${TMP}/alltests 2 > ${TMP}/alltests.tmp
 813                                 cp ${TMP}/alltests.tmp ${TMP}/alltests
 814                                 rm -rf ${TMP}/alltests.tmp;;
 815                                 3)
 816                                 ${LTPROOT}/tools/create_valgrind_check.pl ${TMP}/alltests 3 > ${TMP}/alltests.tmp
 817                                 cp ${TMP}/alltests.tmp ${TMP}/alltests
 818                                 rm -rf ${TMP}/alltests.tmp;;
 819                                 *) echo "Invalid Memory Check Type, or, Valgrind is not available";;
 820                         esac
 821                 fi
 822         fi
 823
 824     # Some tests need to run inside the "bin" directory.
 825     cd "${LTPROOT}/testcases/bin"
 826     "${LTPROOT}/bin/ltp-pan" $QUIET_MODE -e -S $INSTANCES $DURATION -a $$ -n $$ $PRETTY_PRT -f ${TMP}/alltests $LOGFILE $OUTPUTFILE $FAILCMDFILE
 827
 828     if [ $? -eq 0 ]; then
 829       echo "INFO: ltp-pan reported all tests PASS"
 830       VALUE=0
 831       export LTP_EXIT_VALUE=0;
 832     else
 833       echo "INFO: ltp-pan reported some tests FAIL"
 834       VALUE=1
 835       export LTP_EXIT_VALUE=1;
 836     fi
 837     cd ..
 838     echo "LTP Version: $version_date"
 839
 840     if [ "$ALT_HTML_OUT" -eq 1 ] ; then        #User wants the HTML output to be created, it then needs to be generated
 841        export LTP_VERSION=$version_date
 842        export TEST_START_TIME=$test_start_time
 843        export TEST_END_TIME=$(date)
 844        OUTPUT_DIRECTORY=`echo $OUTPUTFILE | cut -c4-`
 845        LOGS_DIRECTORY="$LTPROOT/results"
 846        export TEST_OUTPUT_DIRECTORY="$LTPROOT/output"
 847        export TEST_LOGS_DIRECTORY=$LOGS_DIRECTORY
 848        echo "Generating HTML Output.....!!"
 849        ( perl $LTPROOT/tools/genhtml.pl $LTPROOT/tools/html_report_header.txt test_start test_end test_output execution_status $OUTPUT_DIRECTORY  > $HTMLFILE; )
 850        echo "Generated HTML Output.....!!"
 851        echo "Location: $HTMLFILE";
 852
 853     fi
 854
 855     if [ "$ALT_EMAIL_OUT" -eq 1 ] ; then                      ## User wants reports to be e-mailed
 856        if [ [ ! "$HTMLFILE_NAME" ] -o [ ! "$OUTPUTFILE_NAME" ] -o [ ! "$LOGFILE_NAME" ] ] ; then
 857           ##User does not have output/logs/html-output, nothing to be mailed in this situation
 858           echo "Nothing to be mailed here...."
 859        else
 860            TAR_FILE_NAME=LTP_RUN_$version_date$DEFAULT_FILE_NAME_GENERATION_TIME.tar
 861            if [ "$HTMLFILE_NAME" ] ; then                          ## HTML file Exists
 862               if [ "$ALT_HTML_OUT" -ne 1 ] ; then                  ## The HTML file path is absolute and not $LTPROOT/output
 863                  mkdir -p $LTPROOT/output                          ## We need to create this Directory
 864                  cp $HTMLFILE_NAME $LTPROOT/output/
 865               fi
 866            fi
 867            if [ "$OUTPUTFILE_NAME" ] ; then                        ## Output file exists
 868               if [ "$ALT_DIR_OUT" -ne 1 ] ; then                   ## The Output file path is absolute and not $LTPROOT/output
 869                  mkdir -p $LTPROOT/output                          ## We need to create this Directory
 870                  cp $OUTPUTFILE_NAME $LTPROOT/output/
 871               fi
 872            fi
 873            if [ "$LOGFILE_NAME" ] ; then                           ## Log file exists
 874               if [ "$ALT_DIR_RES" -ne 1 ] ; then                   ## The Log file path is absolute and not $LTPROOT/results
 875                  mkdir -p $LTPROOT/results                         ## We need to create this Directory
 876                  cp $LOGFILE_NAME $LTPROOT/results/
 877               fi
 878            fi
 879            if [ -d $LTPROOT/output ] ; then
 880               tar -cf  ./$TAR_FILE_NAME $LTPROOT/output
 881               if [ $? -eq 0 ]; then
 882                  echo "Created TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/output"
 883               else
 884                  echo "Cannot Create TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/output"
 885               fi
 886            fi
 887            if [ -d $LTPROOT/results ] ; then
 888               tar -uf ./$TAR_FILE_NAME $LTPROOT/results
 889               if [ $? -eq 0 ]; then
 890                  echo "Updated TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/results"
 891               else
 892                  echo "Cannot Update TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/results"
 893               fi
 894            fi
 895            if [ -e $LTPROOT/nohup.out ] ; then                     ## If User would have Chosen nohup to do ltprun
 896               tar -uf ./$TAR_FILE_NAME $LTPROOT/nohup.out
 897               if [ $? -eq 0 ]; then
 898                  echo "Updated TAR File: ./$TAR_FILE_NAME successfully, added $LTPROOT/nohup.out"
 899               else
 900                  echo "Cannot Update TAR File: ./$TAR_FILE_NAME for adding $LTPROOT/nohup.out"
 901               fi
 902            fi
 903            gzip ./$TAR_FILE_NAME                                     ## gzip this guy
 904            if [ $? -eq 0 ]; then
 905               echo "Gunzipped TAR File: ./$TAR_FILE_NAME"
 906            else
 907               echo "Cannot Gunzip TAR File: ./$TAR_FILE_NAME"
 908            fi
 909            if [ -e /usr/bin/mutt ] ; then                          ## This is a better mail client than others
 910               echo "Starting mailing reports to: $EMAIL_TO, file: ./$TAR_FILE_NAME.gz"
 911               mutt -a ./$TAR_FILE_NAME.gz -s "LTP Reports on $test_start_time" $EMAIL_TO < /dev/null
 912               if [ $? -eq 0 ]; then
 913                  echo "Reports Successfully mailed to: $EMAIL_TO"
 914               else
 915                  echo "Reports cannot be mailed to: $EMAIL_TO"
 916               fi
 917            else ## Use our Ageold mail program
 918               echo "Starting mailing reports to: $EMAIL_TO, file: ./$TAR_FILE_NAME.gz"
 919               uuencode ./$TAR_FILE_NAME.gz $TAR_FILE_NAME.gz | mail  $EMAIL_TO -s "LTP Reports on $test_start_time"
 920               if [ $? -eq 0 ]; then
 921                  echo "Reports Successfully mailed to: $EMAIL_TO"
 922               else
 923                  echo "Reports cannot be mailed to: $EMAIL_TO"
 924               fi
 925            fi
 926        fi
 927     fi
 928
 929     [ ! -z "$QUIET_MODE" ] && { echo "INFO: Test end time: $(date)" ; }
 930
 931     [ "$GENLOAD" -eq 1 ] && { killall -9 genload  >/dev/null 2>&1; }
 932     [ "$NETPIPE" -eq 1 ] && { killall -9 NPtcp  >/dev/null 2>&1; }
 933
 934     [ "$ALT_DIR_OUT" -eq 1 ] || [ "$ALT_DIR_RES" -eq 1 ] && \
 935     {
 936     cat <<-EOF >&1
 937
 938        ###############################################################"
 939
 940             Done executing testcases."
 941             LTP Version:  $version_date
 942        ###############################################################"
 943
 944         EOF
 945     }
 946     exit $VALUE
 947 }
 948
 949 cleanup()
 950 {
 951     rm -rf ${TMP}
 952 }
 953
 954 trap "cleanup" 0
 955 setup
 956 main "$@"