:
#
 # tt - Test des Tape-Drives
 #
 # Aufruf   : "tt [(3|8)] [<tmpDir>]
 # Optionen : -c           : cmp statt chksum
 #                           Normalerweise wird nur eine CRC errechnet und
 #                           verglichen. cmp ist "sicherer" aber langsamer
 #                           und 'plattenstrapazierender' (vergl. -t).
 #            -f n         : Groesse der Vergleichsdateien in MB (Default: 10)
 #            -l           : Differenzen beim cmp anzeigen
 #            -n n         : statt einer werden jeweils n Dateien geschrieben
 #            -t <tmpDir2> : zweites Verzeichnis, dass zum Vergleich
 #                           verwendet wird. Der Vergleichslauf erfolgt
 #                           schneller und plattenschonender, wenn <tmpDir>
 #                           bzw. /projects/tmp und <tmpDir2> auf verschie-
 #                           denen Platten liegen.
 #                           Default: tmpDir2 = tmpDir
 #            -v           : verbose
 # Funktion : Test des Tape Drives. Default ist 3 (Exa).
 #            Default fuer tmpDirectory ist /projects/tmp.
 # Beispiel : "tt 8 /tmp"
 #            Testet Spulenmagnetbandstation. Als Verzeichnis fuer
 #            temporaere Dateien dient /tmp.
 #
 #-
 #tmpD $tmpDir/tti$$ $tmpDir2/tto$$
 #
 # erstellt         :         14.08.93 / 18:09 / (mk)
 # letzte Aenderung : 00000 / 14.08.93 / 18:09 / (mk)
 #
#

#
# - zunaechst werden auf dem Tape 10 Dateien zu je $fileSize MB erzeugt
#   - die Dateien haben einen Inhalt, der sie identifiziert
#   - sie haben jeweils verschiedene Blockgroessen
# - die Dateien werden sequentiell gelesen
# - die Dateien werden in umgekehrter Reihenfolge gelesen
# - die Dateien werden "random" gelesen
# - beim Lesen wird jeweils verglichen
#
# - das Ganze laeuft in einer Endlosschleife
#

CleanUp()
{
  rm -f $tmpDir/tti$$ $tmpDir2/tto$$
  echo "\ntt : Abbruch"
  echo "Durchlaeufe      : $tstCount"
  echo "Schreibfehler    : $errWCount"
  echo "Lesefehler       : $errRCount"
  echo "Vergleichsfehler : $errVCount"
  exit 1
}


Blocks()
{
  blockSize=`expr $i \* 1024 + 1024`
  blockCount=`expr $fileSize \* 1024 \* 1024 / $blockSize`
}


Write()
{
  wr -q -o $tape -b $i -n $blockCount $blockSize
}


Read()
{
  rm -f $tti
  if   dd if=$tape of=$tti bs=$blockSize count=$blockCount 2>/dev/null
  then true;
  else echo "R\c"
       errRCount=`expr $errRCount + 1`
       false;
  fi
}


CMP()
{
  wr -q -t -o $tto -b $i -n $blockCount $blockSize
  if   cmp $lOpt $tto $tti
  then true;
  else if   [ -n "$vOpt" ]
       then hd $tto
            hd $tti
       fi
       false;
  fi
}


CRC()
{
  crc=`cat $tti | cksum`
  eval "crctmp=\${crc$i}"
  if   [ -n "$vOpt" ]
  then echo "crc=$crc / crc$i=$crctmp"
  fi
  if   [ "$crc" = "$crctmp" ]
  then true;
  else [ -n "$vOpt" ] && hd $tti
       false;
  fi
}


Test()
{
  if   [ -n "$cOpt" ]
  then CMP;
  else CRC;
  fi
  if   [ "$?" = 0 ]
  then echo ".\c"
  else echo "V\c"
       errVCount=`expr $errVCount + 1`
  fi
}

#
# --------------------------------- MAIN -----------------------------------
#

tape=/dev/exa
tmpDir=/projects/tmp
tmpDir2=/projects/tmp
fileSize=10
fileCount=1
tstCount=0
errWCount=0
errRCount=0
errVCount=0

seq1="0 1 2 3 4 5 6 7 8 9"
seq2="9 8 7 6 5 4 3 2 1 0"
seq3="9 2 7 0 5 8 4 3 1 6"

#seq1="0 1 2"
#seq2="2 1 0"
#seq3="1 0 2"

cOpt=
lOpt=-s
vOpt=
set -- `getopt "lcf:n:t:v" $*`
while [ -n "$1" ]
do  case $1 in
         -c) cOpt=1; shift;;
         -f) fileSize=$2; shift; shift;;
         -l) lOpt=-l; shift;;
         -n) fileCount=$2; shift; shift;;
         -t) tmpDir2=$2; shift; shift;;
         -v) vOpt=1; shift;;
	 --) shift; break;;
	  *) echo "unzulaessige Option : '$1'"
	     exit 1;;
    esac
done

if   [ -n "$1" ]
then if   [ "$1" = 3 ]
     then tape=/dev/exa;
     elif [ "$1" = 8 ]
     then tape=/dev/rmt0;
     else echo "Unzulaessige Angabe fuer tape. 3 oder 8 erwartet"
          exit 1;
     fi
fi
if   [ -n "$2" ]
then [ -d "$2" ] || { echo "'$2' ist kein Verzeichnis";   exit 1; }
     [ -w "$2" ] || { echo "keine Schreibrechte in '$2'"; exit 1; }
     tmpDir=$2
fi

echo "\ntt : tape='$tape', tmpDir='$tmpDir', tmpDir2='$tmpDir2'"

trap "CleanUp" 2 3 15

tti=$tmpDir/tti$$
tto=$tmpDir2/tto$$

if   [ -z "$cOpt" ]
then echo "\nPruefsummen errechnen\c"
     for i in $seq1
     do  Blocks;
	 crc=`wr -q -b $i -n $blockCount $blockSize | cksum`
	 eval "crc$i='$crc'; [ -n '$vOpt' ] && echo \$crc$i"
	 echo ".\c"
     done
fi

while true;
do  mtape fname $tape rew

    echo "\nwrite : \c"
    for i in $seq1
    do  Blocks;
	if   [ -n "$vOpt" ]
	then echo "file $i : blockSize=$blockSize / blockCount=$blockCount"
	fi
	if   Write;
	then echo ".\c"
	else echo "W\c"
	     errWCount=`expr $errWCount + 1`
	fi
    done

    mtape fname $tape rew

    echo "\nread1 : \c"
    for i in $seq1
    do  Blocks; Read && Test
	dd if=$tape of=/dev/null count=1 2>/dev/null # skip filemark
    done

    echo "\nread2 : \c"
    for i in $seq2
    do  if   [ "$i" = 0 ]
        then mtape fname $tape rew
        elif [ "$i" = 1 ]
	then mtape fname $tape rew
	     mtape fname $tape filef 1
        else mtape fname $tape filer 1
	     mtape fname $tape filer 1
	     dd if=$tape of=/dev/null count=1 2>/dev/null # skip filemark
	fi
	Blocks; Read && Test
    done

    echo "\nread3 : \c"
    for i in $seq3
    do  mtape fname $tape rew
	j=$i
	while [ "$j" != 0 ]
	do  mtape fname $tape filef 1
	    j=`expr $j - 1`
	done
	Blocks; Read && Test
    done

    tstCount=`expr $tstCount + 1`
done
