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