TBBT/trace_play/sfs_mgr

   1 #! /bin/sh
   2 #       @(#)sfs_mgr  2.1     97/10/23
   3 #
   4 #    Copyright (c) 1992-1997,2001 by Standard Performance Evaluation Corporation
   5 #       All rights reserved.
   6 #               Standard Performance Evaluation Corporation (SPEC)
   7 #               6585 Merchant Palce, Suite 100
   8 #               Warrenton, VA 20187
   9 #       This product contains benchmarks acquired from several sources who
  10 #       understand and agree with SPEC's goal of creating fair and objective
  11 #       benchmarks to measure computer performance.
  12 #
  13 #       This copyright notice is placed here only to protect SPEC in the
  14 #       event the source is misused in any manner that is contrary to the
  15 #       spirit, the goals and the intent of SPEC.
  16 #
  17 #       The source code is provided to the user or company under the license
  18 #       agreement for the SPEC Benchmark Suite for this product.
  19 #
  20 # *****************************************************************
  21 # *                                                               *
  22 # *     Copyright 1991,1992  Legato Systems, Inc.                 *
  23 # *     Copyright 1991,1992  Auspex Systems, Inc.                 *
  24 # *     Copyright 1991,1992  Data General Corporation             *
  25 # *     Copyright 1991,1992  Digital Equipment Corporation        *
  26 # *     Copyright 1991,1992  Interphase Corporation               *
  27 # *     Copyright 1991,1992  Sun Microsystems, Inc.               *
  28 # *                                                               *
  29 # *****************************************************************
  30 #
  31 # Usage sfs_mgr [-r <rc file>] [-s <suffix>] [-v <level>]
  32 #
  33 # Teelucksingh - Creation (6/17/91)
  34 #
  35 # Starts SFS (sfs_mcr) on clients with parameters
  36 # specified in sfs_rc .
  37 # Starts Prime-client program (sfs_prime)
  38 # Can have multiple runs with incrementing load
  39 # Summarized result(s) placed in sfsres.<suffix>
  40 # Log of multi-client run placed in sfslog.<suffix>
  41 # Individual client result(s) placed in sfs<cnnn>.<suffix>
  42 #
  43 #
  44
  45 # --------------- defined constants and strings --------------
  46 #
  47
  48 STARline='************************************************************************'
  49 RHOSTSCKMSG1="Ensure permissions in .rhosts or hosts.equiv allows remote operation."
  50 RHOSTSCKMSG2="Or check target directory/file existence or permissions."
  51 USAGE="usage: $0 [-r <rc file>] [-s <suffix>] [-v <level>]"
  52
  53 # ----------------- variable initialization ------------------
  54 #
  55
  56 error=FALSE
  57
  58 # --------------- program initialization phase ---------------
  59 #
  60 # get the command line arguments
  61 #
  62 # init with default
  63 #
  64 SUFFIX=out
  65 RC_FILE=./sfs_rc
  66 VALIDATE=0
  67 #
  68 if [ $# -gt 6 ]
  69 then
  70     echo $USAGE
  71     exit 1
  72 fi
  73 while [ $# -gt 0 ]
  74 do
  75     if [ "$#" -lt 2 ]
  76     then
  77         echo $USAGE
  78         exit 1
  79     fi
  80     case $1 in
  81     -r)
  82             RC_FILE=$2
  83             ;;
  84     -s)
  85             SUFFIX=$2
  86             ;;
  87     -v)
  88             VALID_LEVEL=$2
  89             VALIDATE=1
  90             ;;
  91     *)      echo $USAGE
  92             exit 1
  93     esac
  94     shift; shift
  95 done
  96
  97 #
  98 # pass in environment variables from sfs_rc
  99 #
 100 if [ ! -r "$RC_FILE" ]; then
 101     echo "sfs_mgr: missing or protected rc file $RC_FILE"
 102     exit 1
 103 fi
 104 . "$RC_FILE"
 105
 106 #
 107 # Make sure WORK_DIR is defined
 108 #
 109 if [ "$WORK_DIR" = "" ]
 110 then
 111     echo "sfs_mgr: WORK_DIR not defined, check sfs_rc file, exiting."
 112     exit 1
 113 fi
 114
 115 #
 116 # Prime client output files
 117 #
 118 P_OUTFILE=$WORK_DIR/sfsres.$SUFFIX
 119 P_SUMFILE=$WORK_DIR/sfssum.$SUFFIX
 120 P_LOGFILE=$WORK_DIR/sfslog.$SUFFIX
 121 P_VALFILE=$WORK_DIR/sfsval.$SUFFIX
 122
 123 #
 124 # Client pid files
 125 #
 126 SFS_PNT_PID="/tmp/sfs_pnt_pid"
 127 SFS_PRM_PID="/tmp/sfs_prm_pid"
 128 SFS_SYNCD_PID="/tmp/sfs_syncd_pid"
 129
 130 #
 131 # --------------------
 132 # Setup machine/OS dependant parameters
 133 #
 134 # decide whether to use BSD (which one) or SYSV variant of commands
 135 #
 136 # do echo test to get no end-of-line character
 137 #
 138 op=`echo "\c"`
 139 if [ "$op" = "\c" ]; then
 140     ECHO_NONL="echo -n"
 141     NONL=
 142 else
 143     ECHO_NONL="echo"
 144     NONL="\c"
 145 fi
 146
 147 #
 148 # do test to see whether to use hostname or uname
 149 #
 150 if sh -c "hostname > /dev/null 2>&1"  > /dev/null 2>&1
 151 then
 152     HOSTNAME_VAL=`hostname`
 153 elif sh -c "uname -n  > /dev/null 2>&1" > /dev/null 2>&1
 154 then
 155     HOSTNAME_VAL=`uname -n`
 156 else
 157     echo "sfs_mgr: can't use hostname(1) or uname(1), exiting."
 158     echo "sfs_mgr: can't use hostname(1) or uname(1), exiting." \
 159                  >> $P_LOGFILE
 160     exit 1
 161 fi
 162
 163 #
 164 # Make sure RSH is defined, if not set reasonable default
 165 # RSH_CMD overrides RSH if set
 166 #
 167 if [ "$RSH_CMD" != "" ]
 168 then
 169     RSH=$RSH_CMD
 170 fi
 171
 172 if [ "$RSH" = "" ]
 173 then
 174     RSH="rsh"
 175 fi
 176
 177 #
 178 # If CPP is not already defined then
 179 # try to find cpp in the common places, if not there then let PATH find it
 180 #
 181 if [ "$CPP" = "" ]; then
 182     if [ -f /lib/cpp ]
 183     then
 184         CPP=/lib/cpp
 185     elif [ -f /usr/ccs/lib/cpp ]
 186     then
 187         CPP=/usr/ccs/lib/cpp
 188     else
 189         CPP=cpp
 190     fi
 191 fi
 192
 193 #
 194 # trap for signals used by sfs programs
 195 #
 196 if [ "$TRAP_NUMS" = "" ]
 197 then
 198     echo "#include <signal.h>" > /tmp/sfs_tmp1
 199     echo "myprint SIGINT SIGALRM SIGTERM SIGUSR1 SIGUSR2" >> /tmp/sfs_tmp1
 200     cat /tmp/sfs_tmp1 | $CPP | grep myprint | \
 201         awk '{print $2 " " $3 " " $4 " " $5 " " $6}' > /tmp/sfs_tmp2
 202     TRAP_NUMS=`cat /tmp/sfs_tmp2`
 203 fi
 204 rm -f /tmp/sfs_tmp1 /tmp/sfs_tmp2
 205 #
 206 # --------------------
 207
 208 #
 209 # Get NFS version number
 210 #
 211 SFS_PROG="sfs"
 212 if [ "$NFS_VERSION" != "" ]
 213 then
 214     if [ "$NFS_VERSION" = "3" ]
 215     then
 216         SFS_PROG="sfs3"
 217     elif [ "$NFS_VERSION" != "2" ]
 218     then
 219         echo "sfs_mgr: Illegal NFS version number: $NFS_VERSION" \
 220                         >> $P_LOGFILE 2>&1
 221         echo "sfs_mgr: Illegal NFS version number: $NFS_VERSION"
 222         exit 1
 223     fi
 224 fi
 225
 226 #
 227 # print logfile header information
 228 #
 229 echo '========================================================================'\
 230         >>$P_LOGFILE
 231 echo " " >>$P_LOGFILE
 232 echo "SFS NFS Benchmark Prime Client Logfile." >>$P_LOGFILE
 233 echo "        Creation Date: `date`" >>$P_LOGFILE
 234 echo "        Prime Client hostname: $HOSTNAME_VAL" >>$P_LOGFILE
 235
 236 #
 237 # check for mixfile and block-size file
 238 # if specified
 239 #
 240 # check for mixfile
 241 #
 242 if [ "$MIXFILE" != "" -a ! -r "$WORK_DIR/$MIXFILE" ]
 243 then
 244     echo "sfs_mgr: error missing or protected mixfile $WORK_DIR/$MIXFILE" \
 245                 >> $P_LOGFILE 2>&1
 246     echo "sfs_mgr: error missing or protected mixfile $WORK_DIR/$MIXFILE"
 247     exit 1
 248 fi
 249
 250 #
 251 # check for block size file
 252 #
 253 if [ "$BLOCK_FILE" != "" -a ! -r "$WORK_DIR/$BLOCK_FILE" ]
 254 then
 255     echo "sfs_mgr: error missing or protected block size file \
 256             $WORK_DIR/$BLOCK_FILE" >> $P_LOGFILE 2>&1
 257     echo "sfs_mgr: error missing or protected block size file \
 258             $WORK_DIR/$BLOCK_FILE"
 259     exit 1
 260 fi
 261
 262 #
 263 #
 264 NUM_CLIENTS=0
 265 PRIME_CLIENT_NUM=0
 266 for i in $CLIENTS; do
 267     NUM_CLIENTS=`expr $NUM_CLIENTS + 1`
 268     #
 269     # hack: First try a simple remote "echo" to
 270     # /dev/null. If the $RSH fails, then we don't have
 271     # permission to execute the remote command sfs_mcr.
 272     # The initial probe is necessary because we must
 273     # background the sfs_mcr rsh because we're looping
 274     # on all clients, and spawn a bunch, and the rsh won't
 275     # detach from the command. So, the probe.
 276     #
 277     $RSH $i -l $SFS_USER "echo >/dev/null" >/dev/null 2>&1 </dev/null
 278     if [ $? -ne 0 ]; then
 279         echo "sfs_mgr: test rsh to $i failed"
 280         echo "            $RHOSTSCKMSG1"
 281         echo "sfs_mgr: test rsh to $i failed" >> $P_LOGFILE
 282         echo "            $RHOSTSCKMSG1" >> $P_LOGFILE
 283         exit 1
 284     fi
 285
 286     # Get canonical hostname of client $i and see if it is the prime client.
 287     client_name=`$RSH $i -l $SFS_USER 'hostname || uname -n' 2>/dev/null </dev/null`
 288     if [ "$client_name" = $HOSTNAME_VAL ]
 289     then
 290         PRIME_CLIENT_NUM=$NUM_CLIENTS
 291         continue
 292     fi
 293     #
 294     # Also check to make sure the work directory exists
 295     #
 296     exists=`$RSH $i -l $SFS_USER sh -c \"if [ -d $WORK_DIR ]\; then echo 0 \; else echo 1 \; fi\" </dev/null`
 297     if [ "$exists" != 0 ]; then
 298         echo "sfs_mgr: $WORK_DIR on $i does not exist"
 299         echo "sfs_mgr: $WORK_DIR on $i does not exist" >> $P_LOGFILE
 300         exit 1
 301     fi
 302     #
 303     # propagate the mixfile to remote clients
 304     #
 305     if [ "$MIXFILE" != "" ]; then
 306         rcp "$WORK_DIR/$MIXFILE" \
 307            "$SFS_USER"@"$i":"$WORK_DIR/$MIXFILE" >> $P_LOGFILE 2>&1
 308         if [ $? -ne 0 ]; then
 309             echo \
 310             "sfs_mgr: can't rcp mix file $WORK_DIR/$MIXFILE to client $i."
 311             echo "            $RHOSTSCKMSG1"
 312             echo "            $RHOSTSCKMSG2"
 313             echo \
 314             "sfs_mgr: can't rcp mix file $WORK_DIR/$MIXFILE to client $i." \
 315                         >> $P_LOGFILE
 316             echo "            $RHOSTSCKMSG1" >> $P_LOGFILE
 317             echo "            $RHOSTSCKMSG2" >> $P_LOGFILE
 318             exit 1
 319         fi
 320     fi
 321     #
 322     # propagate block size file to remote clients
 323     #
 324     if [ "$BLOCK_FILE" != "" ]; then
 325         rcp "$WORK_DIR/$BLOCK_FILE" \
 326                 "$SFS_USER"@"$i":"$WORK_DIR/$BLOCK_FILE" >> $P_LOGFILE 2>&1
 327         if [ $? -ne 0 ]; then
 328             echo \
 329     "sfs_mgr: can't rcp block size file $WORK_DIR/$BLOCK_FILE to client $i."
 330             echo "            $RHOSTSCKMSG1"
 331             echo "            $RHOSTSCKMSG2"
 332             echo \
 333     "sfs_mgr: can't rcp block size file $WORK_DIR/$BLOCK_FILE to client $i." \
 334                         >> $P_LOGFILE
 335             echo "            $RHOSTSCKMSG1"    >> $P_LOGFILE
 336             echo "            $RHOSTSCKMSG2"    >> $P_LOGFILE
 337             exit 1
 338         fi
 339     fi
 340 done
 341
 342 if [ "$NUM_CLIENTS" -eq 0 ]; then
 343     echo "Cannot run SFS with no clients."
 344     echo "Assign value to CLIENT variable in sfs_rc."
 345     echo "Cannot run SFS with no clients."      >> $P_LOGFILE
 346     echo "Assign value to CLIENT variable in sfs_rc."   >> $P_LOGFILE
 347     exit 1
 348 fi
 349
 350
 351 echo "        Number of Clients: $NUM_CLIENTS" >>$P_LOGFILE
 352 echo "        Client hostname(s): $CLIENTS" >>$P_LOGFILE
 353 echo " " >>$P_LOGFILE
 354
 355 #
 356 # Loop invariant setup
 357 # -------------------
 358 #
 359 # check for program that starts external monitoring
 360 #
 361 if [ "$PRIME_MON_SCRIPT" != "" -a ! -x "$WORK_DIR/$PRIME_MON_SCRIPT" ]
 362 then
 363     echo "sfs_mgr: error missing or not executeable program \
 364         $WORK_DIR/$PRIME_MON_SCRIPT" >> $P_LOGFILE 2>&1
 365     echo "sfs_mgr: error missing or not executeable program \
 366             $WORK_DIR/$PRIME_MON_SCRIPT"
 367     exit 1
 368 fi
 369
 370 #
 371 # Set default number of procs if missing
 372 #
 373 PRCS=$PROCS
 374 if [ "$PRCS" = "" ]; then
 375     PRCS=4
 376 fi
 377
 378 if [ "$MNT_POINTS" = "" ]; then
 379     echo "sfs_mgr: MNT_POINTS not specified" >> $P_LOGFILE 2>&1
 380     echo "sfs_mgr: MNT_POINTS not specified"
 381     exit 1
 382 fi
 383
 384 set `echo $MNT_POINTS`
 385 NUM_MNTS=$#
 386 MPC=`expr $NUM_CLIENTS \* $PRCS`
 387 if [ $NUM_MNTS -ne 1 -a $NUM_MNTS -ne $PRCS -a  $NUM_MNTS -ne $MPC ]; then
 388     ESTR=""
 389     if [ $PROCS -ne $MPC ]; then
 390         ESTR="or $MPC"
 391     fi
 392     echo "sfs_mgr: incorrect number of MNT_POINTS ($NUM_MNTS) must be $PROCS $ESTR" >> $P_LOGFILE 2>&1
 393     echo "sfs_mgr: incorrect number of MNT_POINTS ($NUM_MNTS) must be $PROCS $ESTR"
 394     exit 1
 395 fi
 396
 397 #
 398 # -----------------
 399 #
 400 trap "" $TRAP_NUMS
 401
 402 #
 403 # clean up any 'old' sfs processes
 404 #
 405 if [ -f $SFS_PRM_PID ]; then
 406     kill -2 `cat $SFS_PRM_PID` > /dev/null 2>&1
 407     rm -f $SFS_PRM_PID
 408 fi
 409 if [ -f $SFS_PNT_PID ]; then
 410     kill -2 `cat $SFS_PNT_PID` > /dev/null 2>&1
 411     rm -f $SFS_PNT_PID
 412 fi
 413 if [ -f $SFS_SYNCD_PID ]; then
 414     kill -2 `cat $SFS_SYNCD_PID` > /dev/null 2>&1
 415     rm -f $SFS_SYNCD_PID
 416 fi
 417
 418 #
 419 # Prime Client sfs_syncd logfile
 420 #
 421 S_LOGFILE=$WORK_DIR/syncd_$PRIME_CLIENT_NUM.log
 422
 423 #
 424 # Determine the number of test runs (TOTAL_RUNS)
 425 # from user supplied values in sfs_rc
 426 #
 427 NUM_LOADS=0
 428 LOAD_ARRAY=""
 429 DEFAULT_LOAD=60
 430 #
 431 # get the number of LOAD elements (NUM_LOADS)
 432 #
 433 for i in $LOAD; do
 434     NUM_LOADS=`expr $NUM_LOADS + 1`
 435 done
 436 #
 437 # if NUM_LOADS > 1 then the number of test runs (TOTAL_RUNS) = NUM_LOADS and
 438 # Report conflict if user specifies multiple LOAD elements as well as
 439 # NUM_RUNS > 1.
 440 #
 441 # if NUM_LOADS <= 1 then the number of test runs (TOTAL_RUNS) = NUM_RUNS
 442 #
 443 if [ "$NUM_LOADS" -gt 1 ]; then
 444     TOTAL_RUNS=$NUM_LOADS
 445     LOAD_ARRAY=$LOAD
 446     if [ "$NUM_RUNS" -gt 1 ]; then
 447         echo "Cannot specify an array of LOAD values as well as NUM_RUNS >1."
 448         echo "Cannot specify an array of LOAD values as well as NUM_RUNS >1." \
 449                 >> $P_LOGFILE 2>&1
 450         exit 1
 451     fi
 452 else
 453     TOTAL_RUNS=$NUM_RUNS
 454     if [ "$NUM_LOADS" -eq 0 ]; then
 455         LOAD=$DEFAULT_LOAD
 456     fi
 457     LOAD_ARRAY=$LOAD
 458     i=1
 459     while [ "$i" -lt "$NUM_RUNS" ]; do
 460         LOAD_ARRAY="$LOAD_ARRAY `expr $LOAD + $i \* $INCR_LOAD`"
 461         i=`expr $i + 1`
 462     done
 463 fi
 464
 465 #
 466 # Loop invariant parameters
 467 # create parameter strings here ... from sfs_rc values.
 468 # - SFS_PARAM : sfs parameters
 469 # - SFS_VPARAM : sfs validation parameters
 470 # - SFS_PRIME_PARAM : sfs_prime parameters
 471 SFS_PARAM=
 472 SFS_VPARAM=
 473 SFS_PRIME_PARAM=
 474 #
 475 # get runtime
 476 #
 477 if [ "$RUNTIME" -ne 0 ]; then
 478     SFS_PARAM="$SFS_PARAM -t $RUNTIME"
 479     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -t $RUNTIME"
 480 fi
 481
 482 #
 483 # get mixfile filename, if specified
 484 #
 485 if [ "$MIXFILE" != "" ]; then
 486     SFS_PARAM="$SFS_PARAM -m $WORK_DIR/$MIXFILE"
 487     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -m $WORK_DIR/$MIXFILE"
 488 fi
 489
 490 #
 491 # get sfs DEBUG level
 492 #
 493 if [ "$DEBUG" != "" ]; then
 494     SFS_PARAM="$SFS_PARAM -d $DEBUG"
 495     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -d $DEBUG"
 496 fi
 497
 498 #
 499 # get access percentage
 500 #
 501 if [ "$ACCESS_PCNT" -ne 0 ]; then
 502     SFS_PARAM="$SFS_PARAM -a $ACCESS_PCNT"
 503     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -a $ACCESS_PCNT"
 504 fi
 505
 506 #
 507 # get append percentage
 508 #
 509 if [ "$APPEND_PCNT" -ne 0 ]; then
 510     SFS_PARAM="$SFS_PARAM -A $APPEND_PCNT"
 511     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -A $APPEND_PCNT"
 512 fi
 513
 514 #
 515 # get block size
 516 #
 517 if [ "$BLOCK_SIZE" -ne 0 ]; then
 518     SFS_PARAM="$SFS_PARAM -B $BLOCK_SIZE"
 519     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -B $BLOCK_SIZE"
 520 fi
 521
 522 #
 523 # get block size filename, if specified
 524 #
 525 if [ "$BLOCK_FILE" != "" ]; then
 526     SFS_PARAM="$SFS_PARAM -b $WORK_DIR/$BLOCK_FILE"
 527     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -b $WORK_DIR/$BLOCK_FILE"
 528 fi
 529
 530 #
 531 # get maximum number of outstanding biod reads
 532 #
 533 if [ "$BIOD_MAX_READS" != "" ]; then
 534     SFS_PARAM="$SFS_PARAM -R $BIOD_MAX_READS"
 535     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -R $BIOD_MAX_READS"
 536 fi
 537
 538 #
 539 # get maximum number of outstanding biod writes
 540 #
 541 if [ "$BIOD_MAX_WRITES" != "" ]; then
 542     SFS_PARAM="$SFS_PARAM -W $BIOD_MAX_WRITES"
 543     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -W $BIOD_MAX_WRITES"
 544 fi
 545
 546 #
 547 # get directory count
 548 #
 549 if [ "$DIR_COUNT" -ne 0 ]; then
 550     SFS_PARAM="$SFS_PARAM -D $DIR_COUNT"
 551 fi
 552
 553 #
 554 # get file count
 555 #
 556 if [ -n "$FILE_COUNT" ]; then
 557   if [ "$FILE_COUNT" -ne 0 ]; then
 558     SFS_PARAM="$SFS_PARAM -F $FILE_COUNT"
 559   fi
 560 fi
 561
 562 #
 563 # get symbolic link count
 564 #
 565 if [ "$SYMLINK_COUNT" -ne 0 ]; then
 566     SFS_PARAM="$SFS_PARAM -S $SYMLINK_COUNT"
 567 fi
 568
 569 #
 570 # set flag for raw data dump if option set
 571 #
 572 if [ "$DUMP" != "" ]; then
 573     SFS_PARAM="$SFS_PARAM -z"
 574     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -z"
 575 fi
 576
 577 #
 578 # set flag for NFS/TCP if variable is "1" or "on"
 579 #
 580 if [ "$TCP" != "" ]
 581 then
 582     if [ "$TCP" = "1" -o "$TCP" = "on" ]; then
 583         SFS_PARAM="$SFS_PARAM -Q"
 584         SFS_VPARAM="$SFS_VPARAM -Q"
 585         SFS_PRIME_PARAM="$SFS_PRIME_PARAM -Q"
 586     fi
 587 fi
 588
 589 #
 590 # get number of processes
 591 #
 592 if [ "$PROCS" -ne 0 ]; then
 593     SFS_PARAM="$SFS_PARAM -p $PROCS"
 594     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -p $PROCS"
 595 fi
 596
 597 #
 598 # get warm-up value (allow 0 warmup)
 599 #
 600 if [ "$WARMUP_TIME" != "" ]; then
 601     SFS_PARAM="$SFS_PARAM -w $WARMUP_TIME"
 602     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -w $WARMUP_TIME"
 603 fi
 604
 605 #
 606 # get sfs_prime sleep value
 607 #
 608 if [ "${PRIME_SLEEP:-0}" -gt 0 ]; then
 609     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -s $PRIME_SLEEP"
 610 fi
 611
 612 #
 613 # get file set percentage delta
 614 #
 615 if [ "$FILESET_DELTA" != "" ]; then
 616     SFS_PARAM="$SFS_PARAM -f $FILESET_DELTA"
 617     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -f $FILESET_DELTA"
 618 fi
 619
 620 #
 621 # get sfs_prime timeout value
 622 #
 623 if [ "${PRIME_TIMEOUT:-0}" -gt 0 ]; then
 624     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -x $PRIME_TIMEOUT"
 625 fi
 626
 627 #
 628 # get populate only flag
 629 #
 630 if [ "$POPULATE" != "" ]; then
 631     SFS_PARAM="$SFS_PARAM -P"
 632 fi
 633
 634 #
 635 # check for program that starts external monitoring
 636 #
 637 if [ "$PRIME_MON_SCRIPT" != "" ]; then
 638     SFS_PRIME_PARAM="$SFS_PRIME_PARAM -k $WORK_DIR/$PRIME_MON_SCRIPT"
 639     # check for parameters to the monitor program; use a different method
 640     # to test for nonempty because the arguments may start with a hyphen,
 641     # which would confuse the "test" command.
 642     if [ "x$PRIME_MON_ARGS" != "x" ]; then
 643         SFS_PRIME_PARAM="$SFS_PRIME_PARAM -K '$PRIME_MON_ARGS'"
 644     fi
 645
 646     echo "" >> $P_LOGFILE
 647 fi
 648
 649 #
 650 # Add clients to prime
 651 #
 652 SFS_PRIME_PARAM="$SFS_PRIME_PARAM $CLIENTS"
 653
 654 #
 655 # get prime client hostname
 656 #
 657 SFS_PARAM="$SFS_PARAM -M $HOSTNAME_VAL"
 658
 659 #### End client loop invariant section
 660 #
 661 # VALIDATE stuff
 662 #
 663 if [ "$VALIDATE" -gt 0 ]; then
 664     echo "Executing SFS NFS Validation ..."
 665     #
 666     # if validate option used then take the first client
 667     # from the CLIENT array and run the SFS validation
 668     # suite using the first element on the MOUNT_PNTS list.
 669
 670     set `echo $CLIENTS`
 671     VALID_CLIENT=$1
 672
 673     set `echo $MNT_POINTS`
 674     VALID_MOUNT_PNT=$1
 675
 676     if [ $NUM_MNTS -eq 1 -a -f "$WORK_DIR/$VALID_MOUNT_PNT" ]
 677     then
 678         #
 679         # If the mount point and is actually a file
 680         # name then we assume that it is a file containing a list
 681         # of mount points one line per client, possibly of the format
 682         # hostname:path
 683         #
 684         MNT_PTS=`while read CLNT_LINE MNT_LINE
 685         do
 686             if [ $VALID_CLIENT = $CLNT_LINE ]
 687             then
 688                 echo $MNT_LINE
 689                 break
 690             fi
 691         done < $WORK_DIR/$VALID_MOUNT_PNT`
 692
 693         set `echo $MNT_PTS`
 694         VALID_MOUNT_PNT=$1
 695     fi
 696
 697     echo "Starting SFS NFS validation on client ($VALID_CLIENT)"
 698     echo "    $SFS_DIR/$SFS_PROG $SFS_VPARAM -V $VALID_LEVEL $VALID_MOUNT_PNT"
 699     echo "Starting SFS Validation suite on client ($VALID_CLIENT)" \
 700                 > $P_VALFILE 2>&1
 701     echo "    $SFS_DIR/$SFS_PROG $SFS_VPARAM -V $VALID_LEVEL $VALID_MOUNT_PNT" \
 702                 >> $P_VALFILE 2>&1
 703
 704     # Get canonical hostname of $VALID_CLIENT and see if it is the prime client.
 705     client_name=`$RSH $VALID_CLIENT -l $SFS_USER 'hostname || uname -n' 2>/dev/null </dev/null`
 706     if [ "$client_name" = $HOSTNAME_VAL ]; then
 707         $SFS_DIR/$SFS_PROG $SFS_VPARAM -V $VALID_LEVEL $VALID_MOUNT_PNT \
 708                 >> $P_VALFILE 2>&1
 709         # if error then clean-up and exit
 710         if [ $? -ne 0 ]; then
 711             echo "SFS NFS validation failed."
 712             echo "See $P_VALFILE for results."
 713             exit 1
 714         else
 715             echo "SFS NFS validation completed successfully."
 716             echo "See $P_VALFILE for results."
 717             exit 0
 718         fi
 719     else
 720         $RSH $VALID_CLIENT -l $SFS_USER \
 721             "( cd $WORK_DIR; \
 722             $SFS_DIR/$SFS_PROG $SFS_VPARAM -V $VALID_LEVEL $VALID_MOUNT_PNT )" \
 723             >> $P_VALFILE 2>&1
 724         if [ $? -ne 0 ]; then
 725             echo \
 726             "sfs_mgr: can't run validation pass of sfs on client $VALID_CLIENT."
 727             echo "            $RHOSTSCKMSG1"
 728             echo \
 729             "sfs_mgr: can't run validation pass of sfs on client $VALID_CLIENT." \
 730                                 >> $P_LOGFILE
 731             echo "            $RHOSTSCKMSG1"    >> $P_LOGFILE
 732             exit 1
 733         fi
 734         # if error then clean-up and exit
 735         tail -1 $P_VALFILE | grep -s 'validation completed successfully'
 736         if [ $? -ne 0 ]; then
 737             echo "SFS NFS validation failed."
 738             echo "See $P_VALFILE for results."
 739             echo "SFS NFS validation failed." >> $P_LOGFILE
 740             echo "See $P_VALFILE for results." >> $P_LOGFILE
 741             exit 1
 742         else
 743             echo "SFS NFS validation completed successfully."
 744             echo "See $P_VALFILE for results."
 745             echo "SFS NFS validation completed successfully." >> $P_LOGFILE
 746             echo "See $P_VALFILE for results." >> $P_LOGFILE
 747             exit 0
 748         fi
 749     fi
 750 fi
 751
 752
 753 #
 754 # Prime client /tmp logfiles - used for clean up
 755 #
 756 PRIME_LOG_FILES="/tmp/sfs_PC_sync \
 757                 /tmp/sfs_x$PRIME_CLIENT_NUM \
 758                 /tmp/sfs_CL$PRIME_CLIENT_NUM \
 759                 /tmp/sfs_mpr$PRIME_CLIENT_NUM \
 760                 /tmp/sfs_res*"
 761
 762 #
 763 # start test
 764 # MAIN CLIENT LOOP
 765 #
 766 RUN=1
 767 for LOAD_INDEX in $LOAD_ARRAY; do
 768     LOAD_VALUE=`expr $LOAD_INDEX / $NUM_CLIENTS`
 769
 770     export LOAD_VALUE LOAD_INDEX SUFFIX WORK_DIR
 771
 772     echo " ">>$P_LOGFILE
 773     echo "$STARline" >> $P_LOGFILE
 774     echo "$STARline" >> $P_OUTFILE
 775
 776     #
 777     # clean up /tmp files
 778     #
 779     for i in $PRIME_LOG_FILES; do
 780         if [ -f $i ]; then
 781             if [ -w $i ]; then
 782                 rm $i
 783             else
 784                 echo "sfs_mgr: error could not remove file - $i"
 785                 echo "sfs_mgr: error could not remove file - $i" >> $P_LOGFILE
 786                 exit 1
 787             fi
 788         fi
 789     done
 790     #
 791     # restart the sfs_syncd process
 792     #
 793     if [ -f $SFS_SYNCD_PID ]; then
 794         kill -2 `cat $SFS_SYNCD_PID` > /dev/null 2>&1
 795         rm -f $SFS_SYNCD_PID
 796     fi
 797
 798     trap "" $TRAP_NUMS
 799
 800     echo "Test Run $RUN of $TOTAL_RUNS" >>$P_LOGFILE
 801     echo " " >>$P_LOGFILE
 802     echo "    `date`"
 803     $ECHO_NONL "     Executing run $RUN of $TOTAL_RUNS ... $NONL"
 804     sh -c "$SFS_DIR/sfs_syncd >> $S_LOGFILE 2>&1 &"
 805     sleep 15
 806     echo "Started: sfs_syncd on Prime-Client ($HOSTNAME_VAL)" \
 807         >> $P_LOGFILE
 808
 809     #
 810     # start sfs on all the clients
 811     #
 812     CLIENTS_NUM=1
 813     for i in $CLIENTS; do
 814         #
 815         # compose client's logfile name
 816         #
 817         if [ "$CLIENTS_NUM" -lt 10 ]; then
 818             C_LOGFILE="$WORK_DIR"/sfsc00"$CLIENTS_NUM"."$SUFFIX"
 819         elif [ "$CLIENTS_NUM" -lt 100 ]; then
 820             C_LOGFILE="$WORK_DIR"/sfsc0"$CLIENTS_NUM"."$SUFFIX"
 821         else
 822             C_LOGFILE="$WORK_DIR"/sfsc"$CLIENTS_NUM"."$SUFFIX"
 823         fi
 824
 825         #
 826         # compose client's sfs_syncd logfile name
 827         #
 828         S_LOGFILE=$WORK_DIR/syncd_$CLIENTS_NUM.log
 829
 830         if [ $NUM_MNTS -eq 1 -a -f "$WORK_DIR/$MNT_POINTS" ]
 831         then
 832             #
 833             # If there is only one mount point and it is actually a file
 834             # name then we assume that it is a file containing a list
 835             # of mount points one line per client, possibly of the format
 836             # hostname:path
 837             #
 838             MNT_PTS=`while read CLNT_LINE MNT_LINE
 839             do
 840                 if [ $i = $CLNT_LINE ]
 841                 then
 842                     echo $MNT_LINE
 843                     break
 844                 fi
 845             done < $WORK_DIR/$MNT_POINTS`
 846         else
 847             #
 848             # construct MNT_PTS for this particular CLIENTS_NUM (client)
 849             # from MNT_POINTS, using total number of CLIENTS
 850             # and PRCS [number of processes per client]
 851             #
 852             # PRCS must be a multiple of NUM_MNTS,
 853             # no need to resequence the list of mount points
 854             #
 855             MNT_PTS="$MNT_POINTS"
 856         fi
 857
 858         #
 859         # if prime client in $CLIENT then start sfs locally
 860         #
 861         client_name=`$RSH $i -l $SFS_USER 'hostname || uname -n' 2>/dev/null </dev/null`
 862         if [ "$client_name" = $HOSTNAME_VAL ]; then
 863             echo "`date` $i start:" >>$P_LOGFILE
 864             echo "        $SFS_PROG -N $CLIENTS_NUM -l $LOAD_VALUE $SFS_PARAM $MNT_PTS" \
 865                                     >> $P_LOGFILE
 866
 867             trap "" $TRAP_NUMS
 868             $SFS_DIR/$SFS_PROG -N $CLIENTS_NUM -l $LOAD_VALUE $SFS_PARAM $MNT_PTS \
 869                         >> $C_LOGFILE 2>&1 &
 870         else
 871             #
 872             # Cause remote client to cleanup
 873             #
 874             $RSH $i -l $SFS_USER "( cd $WORK_DIR; \
 875                 $SFS_DIR/sfs_mcr cleanup )" >>/dev/null 2>&1 </dev/null
 876
 877             #
 878             # remotely start sfs_mcr script on clients
 879             #
 880             echo "`date` $i start:" >>$P_LOGFILE
 881             echo "        $SFS_PROG -N $CLIENTS_NUM -l $LOAD_VALUE $SFS_PARAM $MNT_PTS" \
 882                 >> $P_LOGFILE
 883
 884             $RSH $i -l $SFS_USER "( cd $WORK_DIR; \
 885                 $SFS_DIR/sfs_mcr $SFS_PROG $SFS_DIR \
 886                 $S_LOGFILE $C_LOGFILE $CLIENTS_NUM \
 887                 -l $LOAD_VALUE $SFS_PARAM $MNT_PTS ) &"\
 888                 >>/dev/null 2>&1 </dev/null &
 889         fi
 890
 891         #
 892         # increment client num
 893         #
 894         CLIENTS_NUM=`expr $CLIENTS_NUM + 1`
 895     done
 896
 897     #
 898     # start the Prime client program, sfs_prime,
 899     # and wait for completion
 900     #
 901     trap "" $TRAP_NUMS
 902     $SFS_DIR/sfs_prime -l $LOAD_VALUE -C $P_SUMFILE $SFS_PRIME_PARAM \
 903         > /tmp/sfs_mpr$PRIME_CLIENT_NUM 2>> $P_LOGFILE
 904
 905     #
 906     # if error then clean-up set error flag, and break out
 907     #
 908     if [ $? -ne 0 ]; then
 909         echo "sfs_mgr: sfs_prime returned an error, exiting"
 910         echo "sfs_mgr: sfs_prime returned an error, exiting" \
 911                 >> $P_LOGFILE 2>&1
 912         if [ -f $SFS_PNT_PID ]; then
 913             kill -2 `cat $SFS_PNT_PID` > /dev/null 2>&1
 914             rm -f $SFS_PNT_PID
 915         fi
 916         if [ -f $SFS_SYNCD_PID ]; then
 917             kill -2 `cat $SFS_SYNCD_PID` > /dev/null 2>&1
 918             rm -f $SFS_SYNCD_PID
 919         fi
 920         error=TRUE
 921         break   # break out of for loop
 922     fi
 923
 924     #
 925     # record results
 926     #
 927     cat /tmp/sfs_mpr$PRIME_CLIENT_NUM >> $P_LOGFILE
 928     cat /tmp/sfs_mpr$PRIME_CLIENT_NUM >> $P_OUTFILE
 929     rm /tmp/sfs_mpr$PRIME_CLIENT_NUM >> $P_LOGFILE 2>&1
 930
 931     #
 932     # increment RUN value and reset SFS_PARAM
 933     #
 934     RUN=`expr $RUN + 1`
 935     echo " done"
 936     #
 937     echo "" >> $P_LOGFILE
 938     echo "$STARline" >> $P_LOGFILE
 939     echo "$STARline" >> $P_OUTFILE
 940
 941     #
 942     # test run(s) completed
 943     #
 944 done   # END OF MAIN CLIENT LOOP: 'for LOAD_INDEX in $LOAD_ARRAY'
 945
 946 #
 947 # copy log files from clients
 948 #
 949 CLIENTS_NUM=1
 950 for i in $CLIENTS; do
 951     #
 952     # compose client's logfile name
 953     #
 954     if [ "$CLIENTS_NUM" -lt 10 ]; then
 955         C_LOGFILE="$WORK_DIR"/sfsc00"$CLIENTS_NUM"."$SUFFIX"
 956     elif [ "$CLIENTS_NUM" -lt 100 ]; then
 957         C_LOGFILE="$WORK_DIR"/sfsc0"$CLIENTS_NUM"."$SUFFIX"
 958     else
 959         C_LOGFILE="$WORK_DIR"/sfsc"$CLIENTS_NUM"."$SUFFIX"
 960     fi
 961     #
 962     # Copy over the logfiles. We copy the files to a temporary
 963     # file on the chance that either the prime client is also
 964     # a load generating client and we might rcp a file over
 965     # itself, or the $WORK_DIR is NFS mounted by all clients,
 966     # in which case we don't want to really remove the remote
 967     # file since it is the same as the 'local' file on the
 968     # prime. While not necessarily efficient, this is correct.
 969     #
 970     client_name=`$RSH $i -l $SFS_USER 'hostname || uname -n' 2>/dev/null </dev/null`
 971     if [ $client_name != $HOSTNAME_VAL ]; then
 972         #
 973         # copy to temporary file: of different name than target
 974         # in off chance /tmp is our $WORK_DIR
 975         #
 976         rcp "$SFS_USER"@"$i":"$C_LOGFILE" \
 977                 /tmp/sfs"$CLIENTS_NUM"."$SUFFIX"
 978         if [ $? -ne 0 ]; then
 979             echo "sfs_mgr: can't rcp $C_LOGFILE from client $i."
 980             echo "            $RHOSTSCKMSG1"
 981             echo "            $RHOSTSCKMSG2"
 982             echo "sfs_mgr: can't rcp $C_LOGFILE from client $i." >> $P_LOGFILE
 983             echo "            $RHOSTSCKMSG1" >> $P_LOGFILE
 984             echo "            $RHOSTSCKMSG2" >> $P_LOGFILE
 985             exit 1
 986         fi
 987         $RSH $i -l $SFS_USER "/bin/rm $C_LOGFILE"
 988         if [ $? -ne 0 ]; then
 989             echo "sfs_mgr: can't remove $C_LOGFILE on client $i."
 990             echo "            $RHOSTSCKMSG1"
 991             echo "sfs_mgr: can't remove $C_LOGFILE on client $i." >> $P_LOGFILE
 992             echo "            $RHOSTSCKMSG1" >> $P_LOGFILE
 993             exit 1
 994         fi
 995         mv /tmp/sfs"$CLIENTS_NUM"."$SUFFIX" "$C_LOGFILE"
 996     fi
 997     CLIENTS_NUM=`expr $CLIENTS_NUM + 1`
 998 done
 999
1000 #
1001 # if we got an error, terminate sfs_mgr
1002 #
1003 if [ "$error" = TRUE ]; then
1004     exit 1
1005 fi
1006
1007 #
1008 # copy 'raw data dump' files from clients
1009 # only do this for one point, the final one--it dosn't make
1010 # sense to concatenate dumps from different loads
1011 #
1012 if [ "$DUMP" != "" ]; then
1013     CLIENTS_NUM=1
1014     for i in $CLIENTS; do
1015         #
1016         # compose client's raw dump logfile name
1017         #
1018         if [ "$CLIENTS_NUM" -lt 10 ]; then
1019             CLNTNUM=00"$CLIENTS_NUM"
1020         elif [ "$CLIENTS_NUM" -lt 100 ]; then
1021             CLNTNUM=0"$CLIENTS_NUM"
1022         else
1023             CLNTNUM="$CLIENTS_NUM"
1024         fi
1025         PRC=$PROCS
1026         if [ "$PRC" = "" ]; then
1027             PRC=4
1028         fi
1029         PRCJ=0
1030         while [ $PRCJ -lt $PRC ]; do
1031             if [ "$PRCJ" -lt 10 ]; then
1032                 PROCNUM=00"$PRCJ"
1033             elif [ "$PRCJ" -lt 100 ]; then
1034                 PROCNUM=0"$PRCJ"
1035             else
1036                 PROCNUM="$PRCJ"
1037             fi
1038             RAWFILE=c${CLNTNUM}-p${PROCNUM}
1039             #
1040             # copy over the logfiles
1041             # clean out (remove) originals
1042             #
1043             client_name=`$RSH $i -l $SFS_USER 'hostname || uname -n' 2>/dev/null </dev/null`
1044             if [ $client_name != $HOSTNAME_VAL ]; then
1045                 $RSH $i -l $SFS_USER \
1046                     cat /tmp/"$RAWFILE" \
1047                     >> "$WORK_DIR"/"$RAWFILE"."$SUFFIX"
1048                 $RSH $i -l $SFS_USER \
1049                     /bin/rm /tmp/"$RAWFILE"
1050             else
1051                 cat /tmp/"$RAWFILE" \
1052                     >> "$WORK_DIR"/"$RAWFILE"."$SUFFIX"
1053                 /bin/rm /tmp/"$RAWFILE"
1054             fi
1055             PRCJ=`expr $PRCJ + 1`
1056         done
1057         CLIENTS_NUM=`expr $CLIENTS_NUM + 1`
1058     done
1059 fi
1060
1061 #
1062 # cleanup processes before ending
1063 #
1064 if [ -f $SFS_PRM_PID ]; then
1065     kill -2 `cat $SFS_PRM_PID` > /dev/null 2>&1
1066     rm -f $SFS_PRM_PID
1067 fi
1068 if [ -f $SFS_PNT_PID ]; then
1069     kill -2 `cat $SFS_PNT_PID` > /dev/null 2>&1
1070     rm -f $SFS_PNT_PID
1071 fi
1072 if [ -f $SFS_SYNCD_PID ]; then
1073     kill -2 `cat $SFS_SYNCD_PID` > /dev/null 2>&1
1074     rm -f $SFS_SYNCD_PID
1075 fi
1076
1077 #
1078 # cleanup temporary files
1079 #
1080 for i in $PRIME_LOG_FILES; do
1081     if [ -f $i ]; then
1082         if [ -w $i ]; then
1083             rm $i
1084         else
1085             echo "sfs_mgr: error could not remove file - $i"
1086             echo "sfs_mgr: error could not remove file - $i" >> $P_LOGFILE
1087             exit 1
1088         fi
1089     fi
1090 done
1091
1092 echo '========================================================================'\        >>$P_LOGFILE
1093 exit 0