ltp/rwtest.sh

   1 #!/bin/bash
   2 #
   3 # Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
   4 #
   5 # rwtest - a shell wrapper around iogen and doio
   6 #
   7
   8 trap "exit 0" INT  # Until the smarter signal handler is engaged, below.
   9
  10 Prog=$(basename $0)
  11
  12 iOpts=""
  13 dOpts=""
  14 LockRegion=""
  15 Nprocs=1
  16 Files=""
  17 Remove_Test_Files=""
  18 Files_To_Remove=""
  19 MPPrun=""
  20
  21 usage()
  22 {
  23         echo "$Prog: [-chq] [-N name] [ iogen options ] [ doio options ] files" >&2
  24 }
  25
  26 help()
  27 {
  28         echo "\
  29     -c           Cleanup test files created by this invocation on exit.
  30                  Default is to leave them.
  31     -h           This help - ignore all other options/arguments
  32     -F           Only process filenames - does not run iogen & doio.
  33     -P Places    Not used
  34     -S Scenario  Execute an internal scenario.
  35     -N Name      Pan-style name to be printed with error messages.
  36
  37     Options passed through to iogen:
  38     -[afiLmOstT] arg
  39     -o
  40     -q           Set rwtest to be quiet and pass the flag on to iogen.
  41
  42     Options passed through to doio:
  43     -D[rmMVUC] arg
  44     -D[aekv]
  45     -n nprocs    # procs to do simultanious io to the test files.
  46                  Default is 1.  If -n is non-zero, doio's -k option (use
  47                  file locking) is forced.
  48
  49     files        Files to test on.  File names have the following fomat:
  50                  [ size: ] path
  51                  [ free% [ max size ] : ] path
  52                  If no size is specified, the files must exist
  53                  and the contents will be overwritten if testing write or
  54                  writea system calls.  If a size is supplied, an attempt to
  55                  create/grow/shrink path to the desired size will be made.
  56                  size is an integer which defaults to bytes, but may be
  57                  suffixed by 'b', 'k', or 'm' for blocks (4096 byte units),
  58                  kilobytes (1024 byte units), or megabytes (2^20 byte units).
  59
  60                  If the size is a percentage, df is used to find how much
  61                  free space there is (in blocks), and uses that.  The maximum
  62                  size is implied to be in blocks.
  63 " >&2
  64 }
  65
  66 killkids()
  67 {
  68         trap "killkids" INT
  69         if [[ -z $didkids ]]
  70         then
  71                 didkids=done
  72                 kill -INT -$$
  73         fi
  74 }
  75
  76
  77 cleanup_and_exit()
  78 {
  79         if [ -n "$Remove_Test_Files" ]
  80         then
  81                 if [ -n "$Files_To_Remove" ]
  82                 then
  83                         rm -f $Files_To_Remove
  84                 fi
  85         fi
  86
  87         exit $1
  88 }
  89
  90 while (( $# > 0 ))
  91 do      case $1 in
  92         -c)     Remove_Test_Files=yes
  93                 ;;
  94
  95         -d)     debug=$2
  96                 shift
  97                 ;;
  98
  99         -h)     help
 100                 exit 0
 101                 ;;
 102
 103         -F)
 104                 opt_F="-F"      # only process filenames
 105                 ;;
 106
 107         -P)
 108                 PLACES=$2
 109                 shift
 110                 ;;
 111
 112         -S)     Scenario=$2
 113                 shift
 114                 opt_S="-S"
 115                 ;;
 116
 117         -N)     Name="($2)"
 118                 iOpts="$iOpts -N $2"
 119                 dOpts="$dOpts -N $2"
 120                 shift
 121                 ;;
 122
 123         # iogen Options to pass thru ... options with an argument
 124         -[afiLmOstT] )
 125                 iOpts="$iOpts $1 $2"
 126                 shift
 127                 ;;
 128
 129         # iogen Options to pass thru ... just the option
 130         -[o] )
 131                 iOpts="$iOpts $1"
 132                 ;;
 133
 134         # iogen options to look at
 135         -q)
 136                 iOpts="$iOpts $1"
 137                 Quiet=$1
 138                 ;;
 139
 140         # doio Options to pass thru ... options with an argument
 141         -D[rmMVUC] )
 142                 o=${1#-D}
 143                 dOpts="$dOpts -$o $2"
 144                 shift
 145                 ;;
 146
 147         # doio options to pass thru ... just the options
 148         -D[aekv] )
 149                 o=${1#-D}
 150                 dOpts="$dOpts -$o"
 151                 ;;
 152
 153         # doio options to look at
 154         -n | -Dn )
 155                 dOpts="$dOpts $1 $2"
 156                 # force file locking with > 1 process
 157                 if [[ $2 > 1 ]]
 158                 then
 159                         dOpts="$dOpts -k"
 160                 fi
 161                 opt_n="-n"
 162                 shift
 163                 ;;
 164
 165         \? | -*)
 166                 echo "$Prog:  Illegal option $1" >&2
 167                 exit 1
 168                 ;;
 169
 170         *)
 171                 break
 172                 ;;
 173         esac
 174         shift
 175 done
 176
 177 if [[ $TOUTPUT = "NOPASS" ]]; then
 178         iOpts="$iOpts -q"
 179         Quiet="-q"
 180 fi
 181
 182 #
 183 # Hard-Coded Scenario Specifications
 184 #
 185 # FSA           RAW I/O via FSA
 186 # MPPnnn        Run as a <nnn> sized MPP application
 187 # userstripe    create files using user striping
 188 #
 189
 190 if [[ -n "$opt_S" ]]
 191 then
 192         case $Scenario in
 193
 194         FSA )
 195                 # I/O via FSA
 196                 Flags="parallel"
 197                 Nprocs=1
 198                 LockRegion=""
 199         ;;
 200
 201         MPP* )
 202                 # use mpprun...  to cooperate with a batch system, this
 203                 # requires scanning mppview, etc.
 204
 205                 NPE=${Scenario#MPP}
 206                 MPPrun=" mpprun -n $NPE "
 207         ;;
 208         userstripe)
 209                 #create files using user striping
 210                 Oflags=O_PLACE,0xffffffffffffffff,1000
 211         ;;
 212
 213         places*)
 214                 FSIZE=${Scenario#places-}
 215                 oi="$IFS"
 216                 IFS=":"
 217                 set -- $PLACES
 218                 if [ $# -eq 0 ]
 219                 then
 220                         # "this isn't supposed to happen"
 221                         Files="25%:rwtest.$$"
 222                 else
 223                         IFS="$oi"
 224                         PL=${*}
 225                         for p in $PL
 226                         do
 227                                 f="$f "${FSIZE}":"${p}"/rwtest$$"
 228                         done
 229                         set -- $f
 230                 fi
 231         ;;
 232         esac
 233 fi
 234
 235 #
 236 # If no files are specified ...
 237 #       check if PLACES is set; if so, put one file in each place
 238 #       otherwise generate one filename in the current directory.
 239 #
 240
 241 if [ $# -eq 0 ]
 242 then
 243         # put one file in each of $PLACES
 244         Files="25%:rwtest.file"
 245 else
 246         Files=$*
 247 fi
 248
 249 #
 250 # use 'df -PB' to see how many blocks are available, apply a hard limit of
 251 # 1,000,000 blocks if no limit is specified
 252 #
 253
 254 case $(uname -s) in
 255         Linux)                  dfOpts="-P"     ;;
 256         *)                      dfOpts="-PB"    ;;
 257 esac
 258
 259 for f in $Files
 260 do
 261         file=${f##*:}
 262         if [ ! -f "$file" ]
 263         then
 264                 Files_To_Remove="$Files_To_Remove $file"
 265         fi
 266
 267         dir=$(dirname $file)
 268         size=${f%%:*}
 269         if [[ $size = *%* ]]
 270         then
 271
 272                 typeset -i n=0
 273                 while (( n < ${#szcache[*]} ))
 274                 do
 275                         if [[ szcache[$n] = $dir ]]; then
 276                                 break;
 277                         fi
 278                         n=n+1
 279                 done
 280
 281                 if (( n < ${#szcache[*]} ))
 282                 then
 283                         blks=${szblks[$n]}
 284                 else
 285                         blks=$(df $dfOpts $dir |
 286                         (while read fs blks used avail cap mountpoint
 287                          do
 288                                 #echo $fs $blks $used $avail >&2
 289                                 b=$avail
 290                          done
 291                          echo $b) )
 292
 293                         case $(uname) in
 294                         Linux)  blks=$( expr $blks / 2 ) ;;
 295                         esac
 296
 297                         szcache[${#szcache[*]}+1]=$dir
 298                         szblks[${#szblks[*]}+1]=$blks
 299                 fi
 300
 301                 max=${size##*\%}
 302                 if [[ "$max" = "" ]]
 303                 then
 304                         max=1000000
 305                 fi
 306                 size=${size%%\%*}
 307
 308                 sz=$(expr \( $blks '*' $size \) / 100)
 309
 310                 if [[ $sz -gt $max ]]
 311                 then
 312                         sz=$max
 313                 fi
 314                 f=$sz"b:"$file
 315         fi
 316         F[${#F[*]}+1]=$f
 317 done
 318
 319 Files=${F[*]}
 320
 321 if [[ -z ${dOpts} ]]; then
 322         dOpts=-av
 323 fi
 324
 325 if [[ -n "$opt_F" ]]; then
 326
 327         echo $Files
 328
 329 else
 330
 331         [[ -n "$here" ]] || here=`pwd`
 332         if [[ -x ${LTPROOT}/testcases/bin/iogen ]]; then
 333                 IOgen=${LTPROOT}/testcases/bin/iogen
 334         elif [[ -x ${here}/ltp/iogen ]]; then
 335                 IOgen=$here/ltp/iogen
 336         elif [[ -x ./iogen ]]; then
 337                 IOgen=./iogen
 338         else
 339                 echo Cannot find iogen command
 340                 exit 1
 341         fi
 342         if [[ -x ${LTPROOT}/testcases/bin/doio ]]; then
 343                 doIO=${LTPROOT}/testcases/bin/doio
 344         elif [[ -x ${here}/ltp/doio ]]; then
 345                 doIO=$here/ltp/doio
 346         elif [[ -x ./doio ]]; then
 347                 doIO=./doio
 348         else
 349                 echo Cannot find doio command
 350                 exit 1
 351         fi
 352
 353         cmd="$IOgen ${iOpts} ${Files} | $MPPrun $doIO ${dOpts}"
 354
 355         if [[ -z "$Quiet" ]]; then
 356                 echo $cmd
 357         fi
 358
 359         trap "killkids" INT
 360         trap "cleanup_and_exit 2" HUP
 361
 362         ( $IOgen ${iOpts} ${Files}
 363           r=$?
 364           if [ $r -ne 0 ]
 365           then
 366                 echo "$Prog$Name : iogen reported errors (r=$r)" >&2
 367                 kill -HUP $$
 368           fi
 369         ) | $MPPrun $doIO ${dOpts}
 370         r=$?
 371         if [ $r -ne 0 ]
 372         then
 373                 echo "$Prog$Name : doio reported errors (r=$r)" >&2
 374         fi
 375
 376         cleanup_and_exit $r
 377 fi