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