#!/bin/ksh

#DEBUG
#set -x

# RESPECT IDENTATION OF 2 CHARS FOR TABS.

VERSION="2.8.4" # Last modification 12-15-2008

ECHO="/usr/bin/echo"
AWK="/usr/bin/awk"
NAWK="/usr/bin/nawk"
DATE="/usr/bin/date"

trap "$ECHO; $ECHO Guds is exiting; /usr/bin/kill -9 0" 1 2 3 4 5 10 12 15

# Force locale to 'C'
LC_ALL=C
export LC_ALL

PROGRESS=22
PROGRESSLOOP=38

# Set File Variable Names
ADB="adb.out"
IOSTAT="iostat.out"
IOSTATXPNC="iostat-xpnC.out"
IOSTATXPNCMMZ="iostat-xpnCMmz.out"
IOSTATE="iostat-e.out"
MPSTAT="mpstat.out"
VMSTAT="vmstat.out"
PRSTAT="prstat-cpu.out"
PRSTATRSS="prstat-rss.out"
PRSTATSIZ="prstat-siz.out"
PRSTATZ="prstat-Z.out"
PRSTATM="prstat-m.out"
PRSTATML="prstat-mL.out"
VMSTATI="vmstat-i.out"
VMSTATP="vmstat-p.out"
PS="ps_berkeley.out"
PSA="ps.out"
KMASTAT="kmastat.out"
KMAUSERS="kmausers.out"
MEMSTAT="memstat.out"
THREADLIST="threadlist.out"
NETSTAT="netstat"
NETSTATAN="netstat-an.out"
KSTAT="kstat-p.out"
NETSTATK="netstat-k.out"
NETSTATM="netstat-m.out"
NETSTATS="netstat-s.out"
NETSTATRN="netstat-rn.out"
TCPSTATES="tcp-states.out"
LOCKSTATC="lockstat-C.out"
LOCKSTATH="lockstat-H.out"
LOCKSTATPROF1="lockstat-kIW.out"
LOCKSTATPROF2="lockstat-kgIW.out"
LOCKSTATERR="lockstaterrors.out"
IPCSAA="ipcs-A.out"
IPCSA="ipcs-a.out"
UPTIME="uptime.out"
RPCINFO="rpcinfo.out"
RPCINFOP="rpcinfo-p.out"
RPCINFOM="rpcinfo-m.out"
RPCINFOS="rpcinfo-s.out"
NDD="ndd.out"
NFSSTAT="nfsstat.out"
TRAPSTAT="trapstat.out"
TRAPSTATT="trapstat-T.out"
PSRSET="psrset.out"
PSRSETQ="psrset-q.out"
PBIND="pbind.out"
PRTCL_ZONE="prtcl-i_zone.out"
TNF="tnf"
PREX_WAIT=5
ERRORLOG="errors.log"
INFOLOG="info.log"
TIMEZONE="timezone"
IPQOSCONF="ipqosconf-L.out"
INTERRUPTS="interrupts.out"
DLADMSL="dladm-show-link.out"
DLADMSD="dladm-show-dev.out"
DLADMSA="dladm-show-aggr.out"
RCAPSTATP="rcapstat-p.out"
RCAPSTATZ="rcapstat-z.out"
ZPOOLIOSTAT="zpool-iostat.out"

USER=`/usr/bin/id | /usr/bin/cut -d' ' -f1 | /usr/bin/cut -d'(' -f2 | /usr/bin/cut -d')' -f1`
SARQ="sar-q.out"
OS=`/usr/bin/uname -r`
MAJOR=`$ECHO $OS | $AWK -F. '{print $1}'`
MINOR=`$ECHO $OS | $AWK -F. '{print $2}'`
KRNLPATCH=`/usr/bin/uname -v \
| $AWK -F_ '{print $2}' | $AWK -F- '{print $1}'`
KRNLPATCHV=`/usr/bin/uname -v \
| $AWK -F_ '{print $2}' | $AWK -F- '{print $2}'`
FILENO=1
PLATFORM=`uname -i`
ARCH=`uname -m`
PRTDIAG=/usr/platform/${PLATFORM}/sbin/prtdiag

if [ ! $MINOR -ge 7 ]
then 
  BIT=32
else 
  BIT=`/usr/bin/isainfo -b`
fi

if [ $MINOR -ge 10 ]
then
  ZONE="-Z"
else
  ZONE=""
fi

adb_header ()
{
  /usr/bin/printf "\n*\n" >> $ADB
  /usr/bin/printf "ani_max         : total reservable slots on phys (disk) swap\n" >> $ADB
  /usr/bin/printf "ani_free        : # of unallocated phys and mem slots\n" >> $ADB
  /usr/bin/printf "ani_phys_resv   : # of reserved phys (disk) slots\n">> $ADB
  /usr/bin/printf "ani_mem_resv    : # of reserved mem slots\n" >> $ADB
  /usr/bin/printf "ani_locked_swap : # of swap slots locked in reserved mem swap\n\n" >> $ADB
}

adb_calls ()
{
  $ECHO >> $ADB
  if [ $MINOR -ge 8 ]
  then
    DBG="/usr/bin/mdb"
  else
    DBG="/usr/bin/adb"
  fi
  if [ $BIT -eq 32 ]
  then
    CMD="D" 
  else 
    CMD="E" 
  fi
  if [ -x $DBG ]
  then
    ADB_CMD="lotsfree/${CMD}\nminfree/${CMD}\navefree/${CMD}\n"
    ADB_CMD=${ADB_CMD}"freemem/${CMD}\navefree30/${CMD}\n"
    ADB_CMD=${ADB_CMD}"k_anoninfo/\"ani_max\"16t\"ani_free\"8t"
    ADB_CMD=${ADB_CMD}"\"ani_phys_resb\"8t\"ani_mem_resv\"n4${CMD}"
    ADB_CMD=${ADB_CMD}"\"ani_locked_swap\"n${CMD}\n"

    
    ADB_CMD=${ADB_CMD}"nproc/D\nnthread/D\nnswapped/D\n"
    ADB_CMD=${ADB_CMD}"ufs_throttles/D\nufs_HW/D\nufs_LW/D\nufs_WRITES/D"


    $ECHO $ADB_CMD | $DBG -k >> $ADB
  fi
}

Count ()
{
  $ECHO ""
  $ECHO "\tPlease enter the count option for commands that require it."
  $ECHO "\tThese are commands like vmstat and iostat which use an"
  $ECHO "\tinterval and a count to repeat the output."
  $ECHO "\t"
  $ECHO "\tFor example, using a count of 10 and interval of 30"
  $ECHO "\twill cause iostat, vmstat, mpstat, etc to output"
  $ECHO "\t10 sets of data, with 30 seconds between data sets."
  $ECHO "\t"
  $ECHO "\tIf you have not been given a value for this number,"
  $ECHO "\tthe default value will be 10"
  $ECHO "\n\tCount[10]: \c"
  read COUNT
}


Interval ()
{
  $ECHO ""
  $ECHO "\tPlease enter the interval option for commands that require it."
  $ECHO "\tThese are commands like vmstat and iostat which use an"
  $ECHO "\tinterval and count to repeat the output."
  $ECHO "\t"
  $ECHO "\tIf you have not been given a value for this number,"
  $ECHO "\tthe default value will be 30"
  $ECHO "\n\tInterval[30]: \c"
  read INTERVAL
}

Iterations ()
{
  $ECHO ""
  $ECHO "\tPlease enter the number of total data sets for the script"
  $ECHO "\tto capture. Each data set contains the output of one SET"
  $ECHO "\tof a commands output."
  $ECHO "\tFor example, a single data set would contain an entire"
  $ECHO "\t\"ps -elf\" output, and an entire vmstat output, where"
  $ECHO "\tthe vmstat output is made up of a variable number of data"
  $ECHO "\tlines, as defined by \"count\" and \"interval\""
  $ECHO "\t"
  $ECHO "\tIf you have not been given instructions for this number,"
  $ECHO "\tthe default value will be 5"
  $ECHO "\n\tIterations[5]: \c"
  read ITERATIONS
}

Wait ()
{
  $ECHO "\t"
  $ECHO "\tPlease enter the number of seconds to wait between"
  $ECHO "\tcollecting data sets. "
  $ECHO "\tTo ensure correct data collection, any value entered"
  $ECHO "\twill be added to the minimum wait time."
  $ECHO "\t"
  $ECHO "\tIf you have not been given instructions for this number,"
  $ECHO "\tthe default value will be 0"
  $ECHO "\n\tWait[0]: \c"
  read WAIT
}

Case_Number ()
{
  $ECHO ""
  $ECHO "\tPlease enter your case number."
  $ECHO "\tThe case number should only consist of digits."
  $ECHO "\n\tCase: \c"
  read CASE
}

Extended ()
{
  $ECHO ""
  $ECHO "\tDo you want to run extended set of commands?"
  $ECHO "\tlevel 0 : nothing (default)"
  $ECHO "\tlevel 1 : lockstat for contention and hold events"
  $ECHO "\tlevel 2 : L1 + trapstat, lockstat profiling, threadlist, TNF tracing"
  $ECHO "\tlevel 3 : L2 + kmastat, kmausers, memstat"
  $ECHO "\tEnter the level : '0', '1', '2' or '3'."
  $ECHO "\n\tExtended[0]: \c"
  read EXTENDED
}

Dir ()
{
  $ECHO ""
  $ECHO "\tEnter the location of the output directory [/var/tmp]: \c"
  read PDIR
}  

Progress ()
{
  if [ "$QFLAG" -ne 1 ]
  then
    tput sc; /usr/bin/printf "$1/$2"; tput rc
  fi
}
  
#
# Header(string_$1, file_$2)
#
Header ()
{  
  if [ "$ITERATION_COUNT" -eq 1 ]
  then
    $ECHO $1 >> $2 
  fi
}

Create_Directories ()
{
  if [ -z ${PDIR} ] || [ ! -n ${PDIR} ] 
  then
    PDIR=/var/tmp
  fi

  DIR=${PDIR}/${DIR}
  export DIR

  /usr/bin/mkdir -p ${DIR} 2> /dev/null
  if [ $? -ne 0 ]
  then
    $ECHO "Please change permissions so that"
    $ECHO "the directory ${DIR} can be created."
    exit 1
  fi
} 

Count_TCP_states ()
{
  TEMPOUT=TCP`date '+%m%d%y%H%M%S'`
  /usr/bin/touch /tmp/$TEMPOUT;

  for i in `/usr/sbin/ndd /dev/tcp \\? | $AWK '{print $1}'`
  do
    /usr/sbin/ndd /dev/tcp $i >> /tmp/$TEMPOUT
  done

  $ECHO "\n\n" >> $TCPSTATES
  $ECHO "\n\n`date` - started" >> $TCPSTATES

  $ECHO " " >> $TCPSTATES
  $ECHO "The number of TCP_LISTEN connections = " `$NAWK 'BEGIN{OFS=" "}; \
  {print $19}' /tmp/$TEMPOUT | /usr/bin/grep TCP_LISTEN | /usr/bin/wc -l` >> $TCPSTATES

  sleep 1;

  $ECHO "The number of TCP_ESTABLISHED connections = " `$NAWK 'BEGIN{OFS=" "}; \
  {print $19}' /tmp/$TEMPOUT | /usr/bin/grep TCP_ESTABLISHED | /usr/bin/wc -l` >> $TCPSTATES

  sleep 1;

  $ECHO "The number of TCP_CLOSE_WAIT connections = " `$NAWK 'BEGIN{OFS=" "}; \
  {print $19}' /tmp/$TEMPOUT | /usr/bin/grep TCP_CLOSE_WAIT | /usr/bin/wc -l` >> $TCPSTATES

  sleep 1;

  $ECHO "The number of TCP_TIME_WAIT connections = " `$NAWK 'BEGIN{OFS=" "}; \
  {print $19}' /tmp/$TEMPOUT | /usr/bin/grep TCP_TIME_WAIT | /usr/bin/wc -l` >> $TCPSTATES

  sleep 1;
  $ECHO "`date` - ended" >> $TCPSTATES
  /usr/bin/rm /tmp/$TEMPOUT
} # Count_TCP_states


#
# tnf(outputfile_$1, iteration_$2)
#
tnf ()
{
  # Make sure there is enough physical memory for tnf tracing otherwise return
  # we need :  freemem - lotsfree - 8 - 1 > 0
  #                     tnf buffer__|    \__1MB for security                                       
  if [ $BIT -eq 32 ]
  then
    CMD="D" 
  else 
    CMD="E" 
  fi
  freemem=`$ECHO "\`($ECHO "freemem/${CMD}" | /usr/bin/adb -k \
    | grep -v "^$" | /usr/bin/tail -1l \
    | $AWK '{print $2}')\`*8192/1024/1024" | /usr/bin/bc`
  lotsfree=`$ECHO "\`($ECHO "lotsfree/${CMD}"| /usr/bin/adb -k \
    | grep -v "^$" | /usr/bin/tail -1l \
    | $AWK '{print $2}')\`*8192/1024/1024" | /usr/bin/bc`
  free=`expr $freemem \- $lotsfree`
  
  if [ $free -le 9 ]
  then
    $ECHO "\nNot enough memory for TNF tracing\n" >> $ERRORLOG
    return
  fi
  
  /usr/bin/prex -k -s8192 << EOF >> /dev/null
buffer alloc
enable \$all
trace \$all
ktrace on
continue
EOF

  start_date=`date`
  sleep $PREX_WAIT

  /usr/bin/prex -k << EOF >> /dev/null
ktrace off
continue
EOF

  stop_date=`date`    
  /usr/bin/tnfxtract $1.$2
  $ECHO "$start_date - $1.$2 started" >> $DIR/$INFOLOG
  $ECHO "$stop_date - $1.$2 ended" >> $DIR/$INFOLOG
  # compress is less cpu intensive than gzip
  /usr/bin/compress $1.$2

  /usr/bin/prex -k << EOF >> /dev/null
buffer dealloc
continue
EOF
}

#####################################################################
#####################################################################
#####################################################################


while getopts qhvTf:X:b:e:L:l:x:H:c:i:n:w:s:D: name
do
  case $name in
  T)  TIMESTAMP=1;;
  X)  EXTENDED=$OPTARG;;
  H)  HOURS=$OPTARG;;
  q)  EXTENDED=0
      QFLAG=1;;
  b)  CPU=$OPTARG;;
  c)  COUNT=$OPTARG;;
  i)  INTERVAL=$OPTARG;;
  n)  ITERATIONS=$OPTARG;;
  w)  WAIT=$OPTARG;;
  L)  LOCKSTAT_WAIT=$OPTARG;;
  s)  CASE=$OPTARG;;
  f)  FTP=$OPTARG;;
  e)  EMAIL=$OPTARG;;
  l)  SPLIT=$OPTARG;;
  D)  PDIR=$OPTARG;;
  x)  XTRA=$OPTARG;;
  v)  VER=1;;
  h)  /usr/bin/printf "Usage: guds [-q] [-X level] [-T] [-H hours] [-c count] [-i interval] [-n iterations]\n"
      /usr/bin/printf "            [-w wait] [-b cpuid] [-L lockstat_interval] [-s case] [-x \"extra command\"]\n"
      /usr/bin/printf "            [-f ftp_address/ftp_dir] [-e email [-l split]] [-D dir] [-v] [-h]\n"
      /usr/bin/printf " -q : Run in non interactive mode\n"
      /usr/bin/printf " -X : Run extended set of commands depending on specified level\n"
      /usr/bin/printf "      level 0 : nothing (default)\n"
      /usr/bin/printf "      level 1 : lockstat for contention and hold events\n"
      /usr/bin/printf "      level 2 : trapstat, lockstat profiling, threadlist, TNF tracing\n"
      /usr/bin/printf "      level 3 : kmastat, kmausers, memstat (they can take a long time to complete\n"
      /usr/bin/printf "                on systems with a lot of memory)\n"
      /usr/bin/printf "      Increasing extended level can affect system performance.\n"
      /usr/bin/printf " -T : Emit timestamps for commands that loops\n"
      /usr/bin/printf "      (vmstat, mpstat, prstat, iostat)\n"
      /usr/bin/printf " -H : Gather data during the specified hours\n"
      /usr/bin/printf "      i = 30 ; c = 30 ; n = hours * 4 ; w = starts when previous finishes\n"
      /usr/bin/printf " -c : Count value for commands that require it\n"
      /usr/bin/printf "      (vmstat, prstat, iostat, mpstat, sar, ...)\n"
      /usr/bin/printf " -i : Interval value for commands that require it\n"
      /usr/bin/printf "      (vmstat, prstat, iostat, mpstat, sar, ...)\n"
      /usr/bin/printf " -n : Number of iterations the script will do to collect data\n"
      /usr/bin/printf " -w : Wait time (seconds) between each iterations\n"
      /usr/bin/printf "      If set to 0 then the next iteration will start the previous finishes\n"
      /usr/bin/printf " -b : Bind guds to the processor cpuid\n"
      /usr/bin/printf " -L : Specify the interval during which lockstat is gathering data\n"
      /usr/bin/printf "      (default: 5 secondes)\n"
      /usr/bin/printf " -s : Case id used to create the directory where the data are going to be stored in\n"
      /usr/bin/printf " -x : Run extra command during each iteration\n"
      /usr/bin/printf "      Output saved in xtra.out - Errors saved in xtra.err\n"
      /usr/bin/printf " -f : Ftp the output file automaticaly\n"
      /usr/bin/printf "      Make sure to have the ftp_address referenced in your .netrc\n"
      /usr/bin/printf " -e : Email the output file automaticaly\n"
      /usr/bin/printf "      By default, split output file at 10000 lines\n" 
      /usr/bin/printf " -l : Change split size (default: 10000 lines)\n"
      /usr/bin/printf " -D : Change default directory from /var/tmp to <dir>\n"
      /usr/bin/printf " -v : Version\n"
      /usr/bin/printf " -h : This help...\n\n"
      /usr/bin/printf "Example:\n"
      /usr/bin/printf "# guds -q -c10 -i5 -n5 -w0 -s12345678 -x \"sar -g 5 5\" -f sunsolve.sun.com/cores -e foo@sun.com\n"
      /usr/bin/printf "\n# guds -q -X1 -H2 -s12345678\n"  
      exit 2;;
  ?)  /usr/bin/printf "Usage: guds [-q] [-X level] [-T] [-H hours] [-c count] [-i interval] [-n iterations]\n"
      /usr/bin/printf "            [-w wait] [-b cpuid] [-L lockstat_interval] [-s case] [-x \"extra command\"]\n"
      /usr/bin/printf "            [-f ftp_address/ftp_dir] [-e email [-l split]] [-D dir] [-v] [-h]\n"
      exit 2;;
  esac
done

if [ "$VER" -eq 1 ]
then
  $ECHO $VERSION
  exit 1
fi

# We'll do this later if we don't have the data yet...
if [ ! -z $CASE ]
then
  GDATE=`date -u '+%Y.%m.%d.%H.%M'`
  GUDS=guds.`hostid`.`uname -n`-$GDATE
  DIR=$CASE/$GUDS
  FILE=$GUDS.tar
fi

if [ "$HOURS" -gt 0 ]
then
  # Start iteration every 15mn
  QFLAG=1
  INTERVAL=30
  ITERATIONS=`expr $HOURS \* 60 \/ 15`
  COUNT=30
  WAIT=0
fi

# Get Required Input from User
if [ "$QFLAG" -ne 1 ]
then
  clear
  $ECHO "Performance Script"
  $ECHO "------------------"
  $ECHO ""
  $ECHO "This script will run on your system for an amount of time"
  $ECHO "determined by the number of iterations the script is asked"
  $ECHO "to do, and the count and interval supplied for various"
  $ECHO "commands.  If you have not been given specific values, please"
  $ECHO "accept the defaults when asked.  This will cause the script"
  $ECHO "to run for about 30 minutes."
  $ECHO 
  $ECHO "For the best analysis, you should run this script twice."
  $ECHO "1) Run the script when the system is experiencing the"
  $ECHO "   performance problem."
  $ECHO "2) Run it again when the machine is doing well."
  $ECHO
  $ECHO "This will allow the kernel engineer working on the call"
  $ECHO "to compare bad data to baseline data.  Some numbers are"
  $ECHO "meaningless without baseline data."
  $ECHO 
  $ECHO "This script will gather data from your system and put it"
  $ECHO "in a directory called /var/tmp/[case#]."
  $ECHO "\n"
fi

ROOT=`/usr/xpg4/bin/id -u`
if [ $ROOT -ne 0 ] && [ "$QFLAG" -ne 1 ]
then
  $ECHO "**NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE**"
  $ECHO "You are not root.  This will still work, but for best"
  $ECHO "results, please ^C now, and run this script as root."
fi

# Check if patch 109033-02 is installed for Solaris 8, so we can warn before
if [  $MINOR -eq 8 ] && [ "$QFLAG" -ne 1 ]
then
  PATCH=`/usr/bin/showrev -p | nawk '/Patch: 109033/{print $2}' | sort -run | cut -d- -f2`
  if [ ${PATCH:-0} -lt 02 ]
  then
    $ECHO "It is strongly recommended that you install patch 109033-02 before running guds"
    $ECHO "109033-02 fixes a bug in the 'prstat' utility which will prevent guds from"
    $ECHO "gathering accurate cpu usage data using the prstat utility."
    $ECHO "Patch 109033 does not require a reboot, as it only patches the prstat binaries,"
    $ECHO "and can be obtained here:"
    $ECHO "http://sunsolve.sun.com/search/document.do?assetkey=1-21-109033"
    $ECHO "If you wish to install the patch, enter ^C to exit guds"
  fi
fi 

# Get the input the hard way...
while :
do
  # Get the case number
  if [ -z $CASE ]
  then
    while :
    do
      Case_Number
      if [ "$CASE" -le 0 ]
      then
        $ECHO "bad: Invalid Number"
        continue
      fi 2> /dev/null
      GDATE=`$DATE -u '+%Y.%m.%d.%H.%M'`
      GUDS=guds.`hostid`.`uname -n`-$GDATE
      DIR=$CASE/$GUDS
      FILE=$GUDS.tar
      break
    done
  fi

  # Get the count
  if [ -z $COUNT ]
  then
    while :
    do
      Count
      if [ -z $COUNT ]
      then 
        COUNT=10
      fi 2> /dev/null
      if [ "$COUNT" -le 0 ]
      then
        $ECHO "bad: Invalid Number"
        continue
      fi 2> /dev/null
      break
    done
  fi

  # Get the interval
  if [ -z $INTERVAL ]
  then
    while :
    do
      Interval
      if [ -z $INTERVAL ]
      then 
        INTERVAL=30
      fi 2> /dev/null
      if [ "$INTERVAL" -le 0 ]
      then
        $ECHO "bad: Invalid Number"
        continue
      fi 2> /dev/null
      break
    done
  fi

  # Get the iterations
  if [ -z $ITERATIONS ]
  then
    while :
    do
      Iterations
      if [ -z $ITERATIONS ]
      then 
        ITERATIONS=5
      fi 2> /dev/null
      if [ "$ITERATIONS" -le 0 ]
      then
        $ECHO "bad: Iterations."
        continue
      fi 2> /dev/null
      break
    done
  fi

  # Get the wait time between each iteration
  if [ -z $WAIT ]
  then
    while :
    do
      Wait
      if [ -z $WAIT ]
      then 
        WAIT=0
      fi 2> /dev/null
      if [ "$WAIT" -lt 0 ]
      then
        $ECHO "bad: Invalid Number."
        continue
      fi 2> /dev/null  
      break
    done
  fi

  # Get extended flag
  if [ -z $EXTENDED ]
  then
    while :
    do
      Extended
      if [ -z $EXTENDED ]
      then 
        EXTENDED=0
      fi 2> /dev/null
      if [ "$EXTENDED" -lt 0 ] || [ "$EXTENDED" -gt 3 ]
      then
        $ECHO "bad: Invalid Number."
        continue
      fi 2> /dev/null
      break
    done
  fi  

  if [ -z ${PDIR} ]
  then
    while :
    do
      Dir
      if [ -z ${PDIR} ]
      then
        PDIR=/var/tmp
      fi 2> /dev/null
      break
    done
  fi 

  # Bail from the loop if we get this far.
  break
done

Create_Directories

####################
# DON'T REMOVE THIS LINE
####################
cd ${DIR}

#####################################################################
# Main                                                              #
#####################################################################

# Write the user's output to a file, so we know what user typed in.
$ECHO "COUNT = $COUNT" >> user.answers
$ECHO "INTERVAL = $INTERVAL second(s)" >> user.answers
$ECHO "ITERATIONS = $ITERATIONS" >> user.answers
$ECHO "WAIT = $WAIT second(s)" >> user.answers
$ECHO "TIMESTAMP = $TIMESTAMP" >> user.answers
$ECHO "EXTENDED = $EXTENDED" >> user.answers
$ECHO "VERSION = $VERSION" >> user.answers
 
if [ "$QFLAG" -ne 1 ]
then
  $ECHO 
  $ECHO "Starting Data Gathering"
  $ECHO "Collecting System Information"
fi

# if -b then bind guds to $CPU
if [ ! -z $CPU ]
then
  pbind -b $CPU $$ > /dev/null 2>> $ERRORLOG
  if [ $? -eq 0 ]
  then
    $ECHO "CPU_BIND = $CPU" >> user.answers
  fi
fi
Progress 0 $PROGRESS

# Write the adb headers: 
adb_header
Progress 1 $PROGRESS

# Make copies of some important system files
/usr/bin/cp -p /etc/system ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/vfstab ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/release ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /kernel/drv/st.conf ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /kernel/drv/sd.conf ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/path_to_inst ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/syslog.conf ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/inetd.conf ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/name_to_major ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /etc/name_to_sysnum ${DIR} 2>> $ERRORLOG
/usr/bin/cp -p /dev/ksyms ${DIR} 2>> $ERRORLOG
/usr/bin/compress ksyms 2>> $ERRORLOG
Progress 2 $PROGRESS

# Run some commands so see the output, single instance
if [ "$MINOR" -ge 7 ]
then
  /usr/bin/isainfo -v > ${DIR}/isainfo-v.out 2>> $ERRORLOG
  /usr/bin/isainfo -b > ${DIR}/isainfo-b.out 2>> $ERRORLOG
fi
Progress 3 $PROGRESS

/usr/bin/dmesg > ${DIR}/dmesg.out 2>> $ERRORLOG
Progress 4 $PROGRESS

/usr/sbin/modinfo > ${DIR}/modinfo.out 2>> $ERRORLOG
Progress 5 $PROGRESS

/usr/sbin/sysdef -i > ${DIR}/sysdef-i.out 2>> $ERRORLOG
Progress 6 $PROGRESS

/usr/bin/showrev -p > ${DIR}/showrev-p.out 2>> $ERRORLOG
Progress 7 $PROGRESS

/usr/sbin/prtconf -vp > ${DIR}/prtconf-vp.out 2>> $ERRORLOG
Progress 8 $PROGRESS

if [ ! -x "$PRTDIAG" ]
then
  $ECHO "No prtdiag on ${PLATFORM} platform" >> $ERRORLOG
else
  $PRTDIAG -v > ${DIR}/prtdiag-v.out 2>> $ERRORLOG
fi
Progress 9 $PROGRESS

/usr/bin/uname -a > ${DIR}/uname-a.out 2>> $ERRORLOG
Progress 10 $PROGRESS

/usr/bin/pkginfo -l > ${DIR}/pkginfo-l.out 2>> $ERRORLOG
Progress 11 $PROGRESS

/usr/bin/uptime > ${DIR}/uptime.out 2>> $ERRORLOG
Progress 12 $PROGRESS

/usr/sbin/ifconfig -a > ${DIR}/ifconfig-a.out 2>> $ERRORLOG
Progress 13 $PROGRESS

if [ -n "$TZ" ]
then
  $ECHO $TZ > ${DIR}/$TIMEZONE
fi
Progress 14 $PROGRESS

# Check if VxVM is installed
if [ -x /usr/sbin/vxprint ]
then
  VX_PATH=/usr/sbin/
else
  VX_PATH=`grep vxprint /var/sadm/install/contents | grep -v man | $AWK '{print $1}' \
  | /usr/bin/sed 's/vxprint//' | head -1`
fi
if [ "$VX_PATH" ]
then
  $VX_PATH/vxprint -Ath > ${DIR}/vxprint-Ath.out 2>> $ERRORLOG
  $VX_PATH/vxdisk list > ${DIR}/vxdisk-list.out 2>> $ERRORLOG
fi
Progress 15 $PROGRESS

# Check if SDS is installed 
SDS_PATH=`grep metastat /var/sadm/install/contents | grep -v man | $AWK '{print $1}' \
| /usr/bin/sed 's/metastat//' | head -1`
if [ "$SDS_PATH" ]
then
  $SDS_PATH/metastat -p > ${DIR}/metastat-p.out 2>> $ERRORLOG
fi
Progress 16 $PROGRESS

/usr/bin/ls -lisa /dev/rdsk >> ${DIR}/ls-lisa_dev_rdsk.out 2>> $ERRORLOG
Progress 17 $PROGRESS

/usr/sbin/mount > ${DIR}/mount.out 2>> $ERRORLOG
Progress 18 $PROGRESS

/usr/sbin/mount -v > ${DIR}/mount-v.out 2>> $ERRORLOG
Progress 19 $PROGRESS

if [ "$MINOR" -ge 6 ]
then
  /usr/bin/iostat -E > ${DIR}/iostat-e.out 2>> $ERRORLOG
fi
Progress 20 $PROGRESS

if [ ${KRNLPATCH:-0} -ne 108528 ]  ||  [ ${KRNLPATCHV:-0} -ge 13 ]
then
  # Getting ndd parameters for below interface layers #
  $ECHO "\n\n`$DATE` - started" >> $NDD 2>> $ERRORLOG
  #LIST="ip tcp udp icmp arp le hme ba qe qfe ge vge ce nf idn eri"
  LIST="ip tcp udp icmp arp hme ba qe qfe ge vge nf idn eri"
  for i in $LIST
  do
    if [ `/usr/sbin/modinfo | /usr/bin/grep " $i " | /usr/bin/head -1 | /usr/bin/wc -l` -eq 1 ]
    then
      $ECHO "-------------------------------------------" >> $NDD
      $ECHO "-------------------------------------------" >> $NDD
      $ECHO "---------------- ndd /dev/${i} -------------" >> $NDD
      for j in `(/usr/sbin/ndd /dev/${i} \\? 2>> $ERRORLOG) | $AWK '{print $1}' \
      | $AWK -F\( '{print $1}'`
      do
      if [ $j != '?' ]
      then
        if [ "$MINOR" -ge 10 ]
        then
           res=`$ECHO $j | /usr/bin/grep ip_forwarding`
           if [ $? -eq 1 ]
           then
             $ECHO "-------------------------------------------" >> $NDD
             /usr/ucb/echo -n $j " = "  >> $NDD 2>> $ERRORLOG
             /usr/sbin/ndd -get /dev/${i} $j >> $NDD 2>> $ERRORLOG
           fi
        else
          if [ "$MINOR" -lt 10 ]
          then
            $ECHO "-------------------------------------------" >> $NDD
            /usr/ucb/echo -n $j " = "  >> $NDD 2>> $ERRORLOG
            /usr/sbin/ndd -get /dev/${i} $j >> $NDD 2>> $ERRORLOG
          fi
        fi
      fi
      done
      $ECHO >> $NDD
    fi 
  done
  $ECHO "`$DATE` - ended" >> $NDD 2>> $ERRORLOG
fi
Progress 21 $PROGRESS

#
# Solaris 10+ specifics
#
if [ "$MINOR" -ge 10 ]
then
  for zone in `/usr/sbin/zoneadm list`
  do
    /usr/bin/prctl -i zone $zone >> prctl-i_zone.out 2>> $ERRORLOG
  done
  /usr/sbin/ipqosconf -L > $IPQOSCONF 2>> $ERRORLOG
  $ECHO "::interrupts" | /usr/bin/mdb -k > $INTERRUPTS 2>> $ERRORLOG

  # dladm data
  if [ -x /usr/sbin/dladm ]
  then
    /usr/sbin/dladm show-dev  > $DLADMSD 2>> $ERRORLOG
    /usr/sbin/dladm show-link > $DLADMSL 2>> $ERRORLOG
    /usr/sbin/dladm show-aggr > $DLADMSA 2>> $ERRORLOG
  fi
fi
Progress 22 $PROGRESS

if [ "$QFLAG" -ne 1 ]
then
  $ECHO ""
  $ECHO "Collecting performance data..."
fi

ITERATION_COUNT=1
while [ $ITERATIONS -ne 0 ]
do
  if [ "$QFLAG" -ne 1 ]
  then
    $ECHO "Begin Iteration #$ITERATION_COUNT"
  fi
  Progress 0 $PROGRESSLOOP
  Header "/usr/bin/du -ks" dutmp.out
  $ECHO "\n\n`$DATE` - started" >> dutmp.out
  /usr/bin/du -ks /tmp >> dutmp.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> dutmp.out

  Progress 1 $PROGRESSLOOP
  Header "/usr/bin/df -kl $ZONE" df-kl.out
  $ECHO "\n\n`$DATE` - started" >> df-kl.out
  /usr/bin/df -kl $ZONE >> df-kl.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> df-kl.out

  Progress 2 $PROGRESSLOOP
  Header "/usr/bin/df -gl $ZONE" df-gl.out
  $ECHO "\n\n`$DATE` - started" >> df-gl.out
  /usr/bin/df -gl $ZONE >> df-gl.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> df-gl.out

  Progress 3 $PROGRESSLOOP
  Header "/usr/sbin/swap -l" swapl.out
  $ECHO "\n\n`$DATE` - started" >> swapl.out
  /usr/sbin/swap -l >> swapl.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> swapl.out

  Progress 4 $PROGRESSLOOP
  Header "/usr/sbin/swap -s" swaps.out
  $ECHO "\n\n`$DATE` - started" >> swaps.out
  /usr/sbin/swap -s  >> swaps.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> swaps.out

  Header "/usr/bin/vmstat -s" vmstat-s.out 
  $ECHO "\n\n`$DATE` - started" >> vmstat-s.out 
  /usr/bin/vmstat -s  >> vmstat-s.out 2>> $ERRORLOG
  $ECHO "`$DATE` - ended" >> vmstat-s.out 

  Progress 5 $PROGRESSLOOP
  # lockstat (only one can run at a time...)
  if [ "$MINOR" -ge 8 ]
  then
    # Give each lockstat a 3rd of the iteration time if less than 60sec, and run them serially in the background
    if [ -z $LOCKSTAT_WAIT ]
    then
      LOCKSTAT_WAIT=2
    fi

    if [ "$EXTENDED" -ge 1 ]
    then
      Header "/usr/sbin/lockstat -CcwP -n 50000 -D 20 -s 40 sleep $LOCKSTAT_WAIT" $LOCKSTATC
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATC
      /usr/sbin/lockstat -CcwP -n 50000 -D 20 -s 40 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATC 2>> $ERRORLOG
      $ECHO "`date` - ended" >> $LOCKSTATC

      Header "/usr/sbin/lockstat -HcwP -n 50000 -D 20 -s 40 sleep $LOCKSTAT_WAIT" $LOCKSTATH
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATH
      /usr/sbin/lockstat -HcwP -n 50000 -D 20 -s 40 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATH 2>> $ERRORLOG
      $ECHO "`date` - ended" >> $LOCKSTATH    
    fi

    if [ "$EXTENDED" -ge 2 ]
    then
      Header "/usr/sbin/lockstat -kIW -i 977 -D 20 -s 40 sleep $LOCKSTAT_WAIT" $LOCKSTATPROF1
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATPROF1
      /usr/sbin/lockstat -kIW -i 977 -D 20 -s 40 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATPROF1 2>> $ERRORLOG
      $ECHO "`$DATE` - ended" >> $LOCKSTATPROF1

      Header "/usr/sbin/lockstat -kgIW -i 977 -D 20 sleep $LOCKSTAT_WAIT" $LOCKSTATPROF2
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATPROF2
      (/usr/sbin/lockstat -kgIW -i 977 -D 20 -s 40 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATPROF2 2>> $ERRORLOG; \
      $ECHO "`$DATE` - ended" >> $LOCKSTATPROF2)
    fi
  else
    if [ "$EXTENDED" -ge 1 ]
    then 
      Header "/usr/sbin/lockstat -CcwP -n 50000 -D 20 sleep $LOCKSTAT_WAIT" $LOCKSTATC
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATC
      (/usr/sbin/lockstat -CcwP -n 50000 -D 20 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATC 2>> $ERRORLOG;
      $ECHO "`$DATE` - ended" >> $LOCKSTATC)

      Header "/usr/sbin/lockstat -HcwP -n 50000 -D 20 sleep $LOCKSTAT_WAIT" $LOCKSTATH
      $ECHO "\n\n`$DATE` - started" >> $LOCKSTATH
      (/usr/sbin/lockstat -HcwP -n 50000 -D 20 sleep $LOCKSTAT_WAIT 1>> $LOCKSTATH 2>> $ERRORLOG;
      $ECHO "`$DATE` - ended" >> $LOCKSTATH)
    fi
  fi 

  Progress 6 $PROGRESSLOOP
  if [ $USER = "root" ]
  then
    #kmastat
    if [ "$EXTENDED" -ge 3 ]
    then
      if [ "$MINOR" -ge 8 ]
      then
        Header "$ECHO "::kmastat" | /usr/bin/mdb -k" $KMASTAT
        $ECHO "\n\n`$DATE` - started" >> $KMASTAT
        ($ECHO "::kmastat" | /usr/bin/mdb -k >> $KMASTAT; \
        $ECHO "`$DATE` - ended" >> $KMASTAT)
        if [ "$MINOR" -ge 9 ]
        then
           Header "$ECHO "::memstat" | /usr/bin/mdb -k" $MEMSTAT
           ($ECHO "::memstat" | /usr/bin/mdb -k >> $MEMSTAT; \
           $ECHO "`$DATE` - ended" >> $MEMSTAT)
        fi
      else
        Header "$ECHO "kmastat" | /usr/sbin/crash" $KMASTAT
        $ECHO "\n\n`$DATE` - started" >> $KMASTAT
        ($ECHO "kmastat" | /usr/sbin/crash >> $KMASTAT; \
        $ECHO "`$DATE` - ended" >> $KMASTAT)
      fi
    fi

    #kmausers
    KMEMFLAGS=`$ECHO "kmem_flags/D" | /usr/bin/adb -k | grep kmem_flags \
    | tail -1 | awk '{ print $2 }'`
    if [[ $KMEMFLAGS -ne 0 && "$EXTENDED" -ge 3 ]]
    then 
      if [ "$MINOR" -ge 8 ]
      then
        Header "$ECHO "::kmausers" | /usr/bin/mdb -k" $KMAUSERS
        $ECHO "\n\n`$DATE` - started" >> $KMAUSERS
        ($ECHO "::kmausers" | /usr/bin/mdb -k >> $KMAUSERS; \
        $ECHO "`$DATE` - ended" >> $KMAUSERS)
      else
        Header "$ECHO "kmausers" | /usr/sbin/crash" $KMAUSERS
        $ECHO "\n\n`$DATE` - started" >> $KMAUSERS
        ($ECHO "kmausers" | /usr/sbin/crash >> $KMAUSERS; \
        $ECHO "`$DATE` - ended" >> $KMAUSERS)
      fi
    fi

    #adb
    $ECHO "\n\n`$DATE` - started" >> $ADB
    adb_calls
    $ECHO "\n\n`$DATE` - ended" >> $ADB

    #threadlist
    if [[ -r /dev/allkmem && "$EXTENDED" -ge 2 ]]
    then 
      if [ "$MINOR" -ge 8 ]
      then
        Header "$ECHO \"::threadlist -v\" | /usr/bin/mdb -k /dev/ksyms /dev/kmem" $THREADLIST.$FILENO
        $ECHO "\n\n`$DATE` - started" >> $THREADLIST.$FILENO
        ($ECHO "::threadlist -v" | /usr/bin/mdb -k /dev/ksyms /dev/kmem \
        >> $THREADLIST.$FILENO 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $THREADLIST.$FILENO )
	numline=`/usr/bin/cat $THREADLIST.$FILENO | /usr/bin/wc -l `
	if [ "$numline" -lt 10 ]
	then
	  Header "$ECHO \"$<threadlist\" | /usr/bin/mdb -k /dev/ksyms /dev/kmem" $THREADLIST.$FILENO
          $ECHO "\n\n`$DATE` - started" >> $THREADLIST.$FILENO
          ($ECHO "$<threadlist" | /usr/bin/mdb -k /dev/ksyms /dev/kmem \
          >> $THREADLIST.$FILENO 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
          >> $THREADLIST.$FILENO ) 
	fi   
      else
        Header "$ECHO \"$<threadlist\" | /usr/bin/adb -k /dev/ksyms /dev/kmem" $THREADLIST.$FILENO
        $ECHO "\n\n`$DATE` - started" >> $THREADLIST.$FILENO
        ($ECHO "$<threadlist" | /usr/bin/adb -k /dev/ksyms /dev/kmem \
        >> $THREADLIST.$FILENO 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $THREADLIST.$FILENO ) 
      fi
    else
      if [[ ! -r /dev/allkmem && "$EXTENDED" -ge 2 ]]
      then
        $ECHO "/dev/allkmem does not exist" >> $ERRORLOG
      fi
    fi
  fi

  Progress 7 $PROGRESSLOOP
  # vmstat
  Header "/usr/bin/vmstat $INTERVAL $COUNT" $VMSTAT
  $ECHO "\n\n`$DATE` - started" >> $VMSTAT
  if [ -z $TIMESTAMP ]
  then
    (/usr/bin/vmstat $INTERVAL $COUNT >> $VMSTAT 2>> $ERRORLOG; \
    $ECHO "`$DATE` - ended" >> $VMSTAT)&
  else
    (/usr/bin/vmstat $INTERVAL $COUNT | \
    $NAWK '{system("$ECHO `date +%H:%M:%S` \" \\c\""); print}'\
    >> $VMSTAT 2>> $ERRORLOG; \
    $ECHO "`$DATE` - ended" >> $VMSTAT)&
  fi

  Progress 8 $PROGRESSLOOP
  # vmstat -i
  Header "/usr/bin/vmstat -i" $VMSTATI
  $ECHO "\n\n`$DATE` - started" >> $VMSTATI
  (/usr/bin/vmstat -i >> $VMSTATI 2>> $ERRORLOG; \
  $ECHO "`$DATE` - ended" >> $VMSTATI)&

  Progress 9 $PROGRESSLOOP
  # vmstat -p
  if [ "$MINOR" -ge 8 ]
  then
    Header "/usr/bin/vmstat -p $INTERVAL $COUNT" $VMSTATP
    $ECHO "\n\n`$DATE` - started" >> $VMSTATP
    if [ -z $TIMESTAMP ]
    then
      (/usr/bin/vmstat -p $INTERVAL $COUNT >> $VMSTATP 2>> $ERRORLOG; \
      $ECHO "`$DATE` - ended" >> $VMSTATP)&
    else
      (/usr/bin/vmstat -p $INTERVAL $COUNT | \
      $NAWK '{system("$ECHO `date +%H:%M:%S` \" \\c\""); print}'\
      >> $VMSTATP 2>> $ERRORLOG; \
      $ECHO "`$DATE` - ended" >> $VMSTATP)&
    fi
  fi

  Progress 10 $PROGRESSLOOP
  # prstat
  if [ "$MINOR" -ge 8 ]
  then
    # Check if patch 109033-02 is installed for Solaris 8
    # PATCH=`showrev -p | nawk '/Patch: 109033/{print $2}' | sort -run | cut -d- -f2` 
    PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 109033/{print $2}' \
    | /usr/bin/sort -run | /usr/bin/cut -d- -f2` 
    if [  "$MINOR" -ge 9 ] || [ ${PATCH:-0} -ge 02 ]
    then
      Header "/usr/bin/prstat -s cpu -can 10 $INTERVAL $COUNT" $PRSTAT
      $ECHO "\n\n`$DATE` - started" >> $PRSTAT
      if [ -z $TIMESTAMP ]
      then
        (/usr/bin/prstat -s cpu -can 10 $INTERVAL $COUNT >> $PRSTAT 2>> \
        $ERRORLOG; $ECHO "`$DATE` - ended" >> $PRSTAT)&
      else
        (/usr/bin/prstat -s cpu -can 10 $INTERVAL $COUNT | \
        $NAWK '/^[ ]*PID/ {print NL; system("date"); print; next} {print}'\
        >> $PRSTAT 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $PRSTAT)&
      fi  

      Header "/usr/bin/prstat -s rss -can 10 $INTERVAL $COUNT" $PRSTATRSS
      $ECHO "\n\n`$DATE` - started" >> $PRSTATRSS
      if [ -z $TIMESTAMP ]
      then
        (/usr/bin/prstat -s rss -can 10 $INTERVAL $COUNT >> $PRSTATRSS 2>> \
        $ERRORLOG; $ECHO "`$DATE` - ended" >> $PRSTATRSS)&
      else
        (/usr/bin/prstat -s rss -can 10 $INTERVAL $COUNT | \
        $NAWK '/^[ ]*PID/ {print NL; system("date"); print; next} {print}'\
        >> $PRSTATRSS 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $PRSTATRSS)&
      fi

      Header "/usr/bin/prstat -s size -can 10 $INTERVAL $COUNT" $PRSTATSIZ
      $ECHO "\n\n`$DATE` - started" >> $PRSTATSIZ
      if [ -z $TIMESTAMP ]
      then
        (/usr/bin/prstat -s size -can 10 $INTERVAL $COUNT >>$PRSTATSIZ 2>> \
        $ERRORLOG; $ECHO "`$DATE` - ended" >> $PRSTATSIZ)&
      else
        (/usr/bin/prstat -s size -can 10 $INTERVAL $COUNT | \
        $NAWK '/^[ ]*PID/ {print NL; system("date"); print $0; next} {print $0}'\
        >>$PRSTATSIZ 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $PRSTATSIZ)&
      fi

      Header "/usr/bin/prstat -m $INTERVAL $COUNT" $PRSTATM
      $ECHO "\n\n`$DATE` - started" >> $PRSTATM
      if [ -z $TIMESTAMP ]
      then
        (/usr/bin/prstat -m $INTERVAL $COUNT >>$PRSTATM 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $PRSTATM)&
      else
	(/usr/bin/prstat -m $INTERVAL $COUNT | \
	$NAWK '/^[ ]*PID/ {print NL; system("date"); print; next} {print}'\
	>>$PRSTATM 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $PRSTATM)&
      fi

      Header "/usr/bin/prstat -mL $INTERVAL $COUNT" $PRSTATML
      $ECHO "\n\n`$DATE` - started" >> $PRSTATML
      if [ -z $TIMESTAMP ]
      then
        (/usr/bin/prstat -mL $INTERVAL $COUNT >>$PRSTATML 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $PRSTATML)&
      else
        (/usr/bin/prstat -mL $INTERVAL $COUNT | \
        $NAWK '/^[ ]*PID/ {print NL; system("date"); print; next} {print}'\
        >>$PRSTATML 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
        >> $PRSTATML)&
      fi
      
      if [  "$MINOR" -ge 10 ]
      then
        Header "/usr/bin/prstat -Z -n 1 $INTERVAL $COUNT" $PRSTATZ
        $ECHO "\n\n`$DATE` - started" >> $PRSTATZ
        if [  -z $TIMESTAMP ]
        then
          (/usr/bin/prstat -Z -n 1 $INTERVAL $COUNT >>$PRSTATZ 2>> \
          $ERRORLOG; $ECHO "`$DATE` - ended" >> $PRSTATZ)&
        else
          (/usr/bin/prstat -Z -n 1 $INTERVAL $COUNT | \
          $NAWK '/^[ ]*PID/ {print NL; system("date"); print; next} {print}'\
          >>$PRSTATZ 2>> $ERRORLOG; $ECHO "`$DATE` - ended" \
          >> $PRSTATZ)&
        fi
      fi 
    elif [ ${PATCH:-0} -lt 02 ]
    then
      $ECHO "\n\nCan't run prstat cmds - Please, install 109033-02 min." \
      >> $ERRORLOG
    fi          
  fi

  Progress 11 $PROGRESSLOOP
  # trapstat (can't run in parallel)
  if [[ "$MINOR" -ge 9 && "$EXTENDED" -ge 2 ]]
  then
    PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 120011/{print $2}' \
    | /usr/bin/sort -run | /usr/bin/cut -d- -f2`
    if [[ "$ARCH" = "sun4v" && ${PATCH:-0} -lt 14 ]]
    then
      $ECHO "\n\nCan't run trapstat cmds - Please, install 120011-14 min." \
      >> $ERRORLOG
    else
      TRAPSTAT_TIME=`expr $INTERVAL \* $COUNT`
      if [ "$TRAPSTAT_TIME" -gt 60 ]
      then
        Header "/usr/sbin/trapstat 10 6" $TRAPSTAT
        $ECHO "\n\n`$DATE` - started" >> $TRAPSTAT
        (/usr/sbin/trapstat 10 6 >> $TRAPSTAT 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $TRAPSTAT)

        Header "/usr/sbin/trapstat -T 10 6" $TRAPSTATT
        $ECHO "\n\n`$DATE` - started" >> $TRAPSTATT
        (/usr/sbin/trapstat -T 10 6 >> $TRAPSTATT 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $TRAPSTATT)& 
      else
        Header "/usr/sbin/trapstat $INTERVAL $COUNT" $TRAPSTAT
        $ECHO "\n\n`$DATE` - started" >> $TRAPSTAT
        (/usr/sbin/trapstat $INTERVAL $COUNT >> $TRAPSTAT 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $TRAPSTAT)

        Header "/usr/sbin/trapstat -T $INTERVAL $COUNT" $TRAPSTATT
        $ECHO "\n\n`$DATE` - started" >> $TRAPSTATT
        (/usr/sbin/trapstat -T $INTERVAL $COUNT >> $TRAPSTATT 2>> $ERRORLOG; \
        $ECHO "`$DATE` - ended" >> $TRAPSTATT)&	  
      fi  
    fi
  fi

  Progress 12 $PROGRESSLOOP
  # iostat
  Header "/usr/bin/iostat -x $INTERVAL $COUNT" $IOSTAT
  $ECHO "\n\n`$DATE` - started" >> $IOSTAT
  if [ -z $TIMESTAMP ]
  then
    (/usr/bin/iostat -x $INTERVAL $COUNT >> $IOSTAT 2>> $ERRORLOG; \
    $ECHO "`$DATE` - ended" >> $IOSTAT)&
  else
    if [ "$MINOR" -ge 8 ]
    then
      (/usr/bin/iostat -T d -x $INTERVAL $COUNT >> $IOSTAT 2>> $ERRORLOG; \
      $ECHO "`$DATE` - ended" >> $IOSTAT)&
    else
      (/usr/bin/iostat -x $INTERVAL $COUNT | \
      $NAWK '/^[ ]*extended/ {print NL; system("date"); print; next} {print}'\
      >> $IOSTAT 2>> $ERRORLOG; \
      $ECHO "`$DATE` - ended" >> $IOSTAT)&
    fi
  fi

  Progress 13 $PROGRESSLOOP
  if [ "$MINOR" -ge 8 ]
  then
    Header "/usr/bin/iostat -xpnC $INTERVAL $COUNT" $IOSTATXPNC
    $ECHO "\n\n`$DATE` - started" >> $IOSTATXPNC
    if [ -z $TIMESTAMP ]
    then  
      (/usr/bin/iostat -xpnC $INTERVAL $COUNT >> $IOSTATXPNC 2>> $ERRORLOG;\
      $ECHO "`$DATE` - ended" >> $IOSTATXPNC)&
    else
      if [ "$MINOR" -ge 8 ]
      then
        (/usr/bin/iostat -T d -xpnC $INTERVAL $COUNT >> $IOSTATXPNC 2>> $ERRORLOG;\
        $ECHO "`$DATE` - ended" >> $IOSTATXPNC)&
      else
        (/usr/bin/iostat -xpnC $INTERVAL $COUNT | \
        $NAWK '/^[ ]*extended/ {print NL; system("date"); print; next} {print}'\
        >> $IOSTATXPNC 2>> $ERRORLOG;\
        $ECHO "`$DATE` - ended" >> $IOSTATXPNC)&
      fi
    fi

    if [  "$MINOR" -ge 9 ]
    then 	
      Header "/usr/bin/iostat -xpnCXMmz $INTERVAL $COUNT" $IOSTATXPNCMMZ
    else
      Header "/usr/bin/iostat -xpnCMmz $INTERVAL $COUNT" $IOSTATXPNCMMZ
    fi
    $ECHO "\n\n`$DATE` - started" >> $IOSTATXPNCMMZ
    if [ -z $TIMESTAMP ]
    then
      if [  "$MINOR" -ge 9 ]
      then
        (/usr/bin/iostat -xpnCXMmz $INTERVAL $COUNT \
        >> $IOSTATXPNCMMZ 2>> $ERRORLOG; \
        $ECHO  "`$DATE` - ended" >> $IOSTATXPNCMMZ)&
      else
	(/usr/bin/iostat -xpnCMmz $INTERVAL $COUNT \
        >> $IOSTATXPNCMMZ 2>> $ERRORLOG; \
        $ECHO  "`$DATE` - ended" >> $IOSTATXPNCMMZ)&
      fi
    else
      if [ "$MINOR" -eq 8 ]
      then 
        (/usr/bin/iostat -T d -xpnCMmz $INTERVAL $COUNT >> $IOSTATXPNCMMZ 2>> $ERRORLOG;\
        $ECHO  "`$DATE` - ended" >> $IOSTATXPNCMMZ)&
      elif [ "$MINOR" -ge 9 ]
      then
	(/usr/bin/iostat -T d -xpnCXMmz $INTERVAL $COUNT >> $IOSTATXPNCMMZ 2>> $
ERRORLOG;\
        $ECHO  "`$DATE` - ended" >> $IOSTATXPNCMMZ)&
      else
        (/usr/bin/iostat -xpnCMmz $INTERVAL $COUNT | \
        $NAWK '/^[ ]*extended/ {print NL; system("date"); print; next} {print}'\
        >> $IOSTATXPNCMMZ 2>> $ERRORLOG; \
        $ECHO  "`$DATE` - ended" >> $IOSTATXPNCMMZ)&
      fi
    fi
  fi

  Progress 14 $PROGRESSLOOP
  # mpstat
  Header "/usr/bin/mpstat $INTERVAL $COUNT" $MPSTAT
  $ECHO "\n\n`$DATE` - started" >> $MPSTAT
  if [ -z $TIMESTAMP ]
  then
    (/usr/bin/mpstat $INTERVAL $COUNT >> $MPSTAT 2>> $ERRORLOG; \
    $ECHO "`$DATE` - ended" >> $MPSTAT)&
  else
    (/usr/bin/mpstat $INTERVAL $COUNT | \
    $NAWK '{system("$ECHO `date +%H:%M:%S` \" \\c\""); print}'\
    >> $MPSTAT 2>> $ERRORLOG; \
    $ECHO "`$DATE` - ended" >> $MPSTAT)&
  fi

  Progress 15 $PROGRESSLOOP
  # The old Berkely style ps only for OS < 5.8
  if [ "$MINOR" -lt 8 ]
  then
    Header "/usr/ucb/ps -auxww" $PS
    $ECHO "\n\n`$DATE` - started" >> $PS
    (/usr/ucb/ps -auxww >> $PS; $ECHO "`$DATE` - ended" >> $PS)&
  fi

  Progress 16 $PROGRESSLOOP
  # The AT&T ps
  if [ "$MINOR" -ge 10 ]
  then
    Header "/usr/bin/ps -eo 'zone user s pri pid ppid pcpu pmem vsz rss stime time nlwp psr args' | sort -r -k 6,6" $PSA.$FILENO
    $ECHO "\n\n`$DATE` - started" >> $PSA.$FILENO
    (/usr/bin/ps -eo 'zone user s pri pid ppid pcpu pmem vsz rss stime time nlwp psr args' | sort -r -k 6,6  \
    >> $PSA.$FILENO ; $ECHO "`$DATE` - ended" \
    >> $PSA.$FILENO )& 
  else
    Header "/usr/bin/ps -eo 'user s pri pid ppid pcpu pmem vsz rss stime time nlwp psr args' | sort -r -k 6,6" $PSA.$FILENO
    $ECHO "\n\n`$DATE` - started" >> $PSA.$FILENO
    (/usr/bin/ps -eo 'user s pri pid ppid pcpu pmem vsz rss stime time nlwp psr args' | sort -r -k 6,6 \
    >> $PSA.$FILENO ; $ECHO "`$DATE` - ended" \
    >> $PSA.$FILENO )&
  fi  

  Progress 17 $PROGRESSLOOP
  # sar -q
  if [ "$MINOR" -eq 8 ]
  then
    $ECHO "\n Patch 110941-03 should be installed to get consistent result" >> $SARQ
  fi

  if [ "$MINOR" -eq 7 ]
  then
    $ECHO "\n Patch 106946-07 should be installed to get consistent result" >> $SARQ
  fi

  if [ "$MINOR" -eq 6 ]
  then
    $ECHO "\n Patch 106818-05 should be installed to get consistent result" >> $SARQ
  fi

  Header "/usr/bin/sar -q $INTERVAL $COUNT" $SARQ
  $ECHO "\n\n`$DATE` - started" >> $SARQ
  (/usr/bin/sar -q $INTERVAL $COUNT >> $SARQ 2>> $ERRORLOG; $ECHO "`$DATE` - ended" >> $SARQ)&

 Progress 18 $PROGRESSLOOP
  # ipcs
  if [ "$MINOR" -ge 7 ]
  then
    Header "/usr/bin/ipcs -A $ZONE" $IPCSAA
    $ECHO "\n\n`$DATE` - started" >> $IPCSAA
    (/usr/bin/ipcs -A $ZONE 1>> ${DIR}/$IPCSAA 2>> $ERRORLOG; $ECHO "`$DATE` - ended" >> $IPCSAA)&
  else
    Header "/usr/bin/ipcs -a" $IPCSA
    $ECHO "\n\n`$DATE` - started" >> $IPCSA
    (/usr/bin/ipcs -a 1>> ${DIR}/$IPCSA 2>> $ERRORLOG; $ECHO "`$DATE` - ended" >> $IPCSA)&
  fi

  Progress 19 $PROGRESSLOOP
  # netstat
  Header "/usr/bin/netstat -an" $NETSTATAN
  $ECHO "\n\n`$DATE` - started" >> $NETSTATAN
  (/usr/bin/netstat -an >> $NETSTATAN; $ECHO "`$DATE` - ended" >> $NETSTATAN)&  
  Progress 20 $PROGRESSLOOP
  if [ $MINOR -ge 8 ]
  then
    for IF in `/usr/sbin/ifconfig -a | $AWK -e '/^[^ \t]*:/ {print $1}' \
    | /usr/bin/sed "s/:.*//" | /usr/bin/sort -u`
    do
      NETSTATIN="netstat-in.${IF}"
      Header "/usr/bin/netstat -in -I $IF $INTERVAL $COUNT" $NETSTATIN
      $ECHO "\n\n`$DATE` - started" >> $NETSTATIN
      (/usr/bin/netstat -in -I $IF $INTERVAL $COUNT >> $NETSTATIN; \
      $ECHO "`$DATE` - ended" >> $NETSTATIN)&
    done
  else
    NETSTATIN="netstat-in.out"
    Header "/usr/bin/netstat -in" $NETSTATIN
    $ECHO "\n\n`$DATE` - started" >> $NETSTATIN
    (/usr/bin/netstat -in >> $NETSTATIN; $ECHO "`$DATE` - ended" >> $NETSTATIN)&
  fi

  Progress 21 $PROGRESSLOOP
  Header "/usr/bin/netstat -m" $NETSTATM
  $ECHO "\n\n`date` - started" >> $NETSTATM
  (/usr/bin/netstat -m >> $NETSTATM; $ECHO "`$DATE` - ended" >> $NETSTATM)&

  Progress 22 $PROGRESSLOOP
  Header "/usr/bin/netstat -s" $NETSTATS
  $ECHO "\n\n`date` - started" >> $NETSTATS
  (/usr/bin/netstat -s >> $NETSTATS; $ECHO "`$DATE` - ended" >> $NETSTATS)&

  Progress 23 $PROGRESSLOOP
  Header "/usr/bin/netstat -rvn" $NETSTATRN
  $ECHO "\n\n`date` - started" >> $NETSTATRN
  (/usr/bin/netstat -rvn >> $NETSTATRN; $ECHO "`$DATE` - ended" >> $NETSTATRN)&

  Progress 24 $PROGRESSLOOP
  if [ ${KRNLPATCH:-0} -ne 108528 ]  ||  [ ${KRNLPATCHV:-0} -ge 13 ]
  then
    Count_TCP_states
  fi

  Progress 25 $PROGRESSLOOP
  # rpcinfo
  Header "/usr/bin/rpcinfo" $RPCINFO
  $ECHO "\n\n`$DATE` - started" >> $RPCINFO 2>&1
  /usr/bin/rpcinfo >> $RPCINFO 2>&1
  $ECHO "`$DATE` - ended" >> $RPCINFO 2>&1
  Progress 26 $PROGRESSLOOP
  Header "/usr/bin/rpcinfo -p" $RPCINFOP
  $ECHO "\n\n`$DATE` - started" >> $RPCINFOP 2>&1
  /usr/bin/rpcinfo -p >> $RPCINFOP 2>&1
  $ECHO "`$DATE` - ended" >> $RPCINFOP 2>&1
  Progress 27 $PROGRESSLOOP
  Header "/usr/bin/rpcinfo -m" $RPCINFOM
  $ECHO "\n\n`$DATE` - started" >> $RPCINFOM 2>&1
  /usr/bin/rpcinfo -m >> $RPCINFOM 2>&1
  $ECHO "`$DATE` - ended" >> $RPCINFOM 2>&1
  Progress 28 $PROGRESSLOOP
  Header "/usr/bin/rpcinfo -s" $RPCINFOS
  $ECHO "\n\n`$DATE` - started" >> $RPCINFOS 2>&1
  /usr/bin/rpcinfo -s >> $RPCINFOS 2>&1
  $ECHO "`$DATE` - ended" >> $RPCINFOS 2>&1

  Progress 29 $PROGRESSLOOP
  # kstat / netstat -k
  if [ "$MINOR" -ge 8 ]
  then
    modinfo | grep qlc 1> /dev/null
    if [ $? -eq 1 ] # qlc driver not in use
    then 
      modinfo | grep llc1 1> /dev/null
      if [ $? -eq 1 ] # llc1 driver not in use
      then 
        Header "/usr/bin/kstat -p" $KSTAT
        $ECHO "\n\n`$DATE` - started" >> $KSTAT
        (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
      elif [ "$MINOR" -eq 9 ] # llc1 driver in use
      then
        # Check if patch 117071-01 is installed
        PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 117071/{print $2}' \
        | /usr/bin/sort -run | /usr/bin/cut -d- -f2`
        if [ ${PATCH:-0} -ge 01 ]
        then
          Header "/usr/bin/kstat -p" $KSTAT
          $ECHO "\n\n`$DATE` - started" >> $KSTAT
          (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
	else
	  $ECHO "kstat: patchid 117071-01 is missing" >> $ERRORLOG
        fi
      elif [ "$MINOR" -gt 9 ] # Solaris 10 and above
      then
        Header "/usr/bin/kstat -p" $KSTAT
        $ECHO "\n\n`$DATE` - started" >> $KSTAT
        (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
      fi # llc1
    else [ $? -eq 0 ] # qlc driver in use
      if [ "$MINOR" -eq 8 ]
      then
        # Check if patch 111097-13 is installed
        PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 111097/{print $2}' \
        | /usr/bin/sort -run | /usr/bin/cut -d- -f2`
        if [ ${PATCH:-0} -ge 13 ]
        then
          Header "/usr/bin/kstat -p" $KSTAT
          $ECHO "\n\n`$DATE` - started" >> $KSTAT
          (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
        else
	  $ECHO "kstat: patchid 111097-13 is missing" >> $ERRORLOG
	fi
      elif [ "$MINOR" -eq 9 ]
      then
        # Check if patch 113042-05 is installed
        PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 113042/{print $2}' \
        | /usr/bin/sort -run | /usr/bin/cut -d- -f2`
        if [ ${PATCH:-0} -ge 05 ]
        then
          modinfo | grep llc1 1> /dev/null
          if [ $? -eq 0 ] # llc1 module is loaded
          then
            # Check if patch 117071-01 is installed
            # PATCH=`showrev -p | nawk '/Patch: 117071/{print $2}' | sort -run | cut -d- -f2`
            PATCH=`/usr/bin/cat showrev-p.out | $NAWK '/Patch: 117071/{print $2}' \
            | /usr/bin/sort -run | /usr/bin/cut -d- -f2`
            if [ ${PATCH:-0} -ge 01 ]
            then
              Header "/usr/bin/kstat -p" $KSTAT
              $ECHO "\n\n`$DATE` - started" >> $KSTAT
              (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
	    else
	      $ECHO "kstat: patchid 117071-01 is missing" >> $ERRORLOG
            fi
          else # llc1 not loaded
	      Header "/usr/bin/kstat -p" $KSTAT
              $ECHO "\n\n`$DATE` - started" >> $KSTAT
              (/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&
	  fi #llc1
	else
	  $ECHO "kstat: patchid 113042-05 is missing" >> $ERRORLOG
        fi
      else # Solaris 10 and above
      	Header "/usr/bin/kstat -p" $KSTAT
	$ECHO "\n\n`$DATE` - started" >> $KSTAT
	(/usr/bin/kstat -p >> $KSTAT; $ECHO "`$DATE` - ended" >> $KSTAT)&  
      fi
    fi # qlc
  elif [ "$MINOR" -gt 5 ]
  then
    if [[ ${KRNLPATCH:-0} -eq 105181 && ${KRNLPATCHV:-0} -ge 33 ]] \
    || [[ ${KRNLPATCH:-0} -eq 106541 && ${KRNLPATCHV:-0} -ge 20 ]] \
    || [ "$MINOR" -gt 7 ]
    then
      Header "/usr/bin/netstat -k" $NETSTATK
      $ECHO "\n\n`$DATE` - started" >> $NETSTATK
      (/usr/bin/netstat -k >> $NETSTATK; $ECHO "`$DATE` - ended" >> $NETSTATK)&
    fi
  fi

  Progress 30 $PROGRESSLOOP
  # nfsstat
  Header "/usr/bin/nfsstat" $NFSSTAT
  $ECHO "\n\n`$DATE` - started" >> $NFSSTAT
  (/usr/bin/nfsstat >> $NFSSTAT; $ECHO "`$DATE` - ended" >> $NFSSTAT)&

  Progress 31 $PROGRESSLOOP
  # vxstat
  if [ -x /usr/sbin/vxstat -a -x /usr/sbin/vxdg ]
  then
    for DG in `/usr/sbin/vxdg list | grep enabled | $AWK '{print $1}'`
    do
      VXSTAT_DG="vxstat.${DG}"
      Header "/usr/sbin/vxstat -g $DG -i ${INTERVAL} -c ${COUNT} -psvd" $VXSTAT_DG
      $ECHO "\n\n`$DATE` - started" >> $VXSTAT_DG
      (/usr/sbin/vxstat -g $DG -i ${INTERVAL} -c ${COUNT} -psvd >> $VXSTAT_DG; \
      $ECHO "`$DATE` - ended" 2>&1 >> $VXSTAT_DG )&
    done
  fi

  Progress 32 $PROGRESSLOOP
  # processor sets and bindings.
  Header "/usr/sbin/psrset" $PSRSET
  $ECHO "\n\n`$DATE` - started" >> $PSRSET
  (/usr/sbin/psrset >> $PSRSET 2>/dev/null; $ECHO "`$DATE` - ended" >> $PSRSET)&

  Progress 33 $PROGRESSLOOP
  Header "/usr/sbin/psrset -q" $PSRSETQ
  $ECHO "\n\n`$DATE` - started" >> $PSRSETQ
  (/usr/sbin/psrset -q >> $PSRSETQ 2>/dev/null; $ECHO "`$DATE` - ended" >> $PSRSETQ)&

  Progress 34 $PROGRESSLOOP
  Header "/usr/sbin/pbind" $PBIND
  $ECHO "\n\n`$DATE` - started" >> $PBIND
  (/usr/sbin/pbind >> $PBIND 2>/dev/null; $ECHO "`$DATE` - ended" >> $PBIND)&

  Progress 35 $PROGRESSLOOP
  # rcapstat data
  if [ $MINOR -ge 10 ] && [ -x /usr/bin/rcapstat ]
  then
    Header "/usr/bin/rcapstat -p $INTERVAL $COUNT" $RCAPSTATP
    $ECHO "\n\n`$DATE` - started" >> $RCAPSTATP
    (/usr/bin/rcapstat -p $INTERVAL $COUNT >> $RCAPSTATP 2>>$ERRORLOG; $ECHO "`$DATE` - ended" >> $RCAPSTATP)&

    Header "/usr/bin/rcapstat -z $INTERVAL $COUNT" $RCAPSTATZ
    $ECHO "\n\n`$DATE` - started" >> $RCAPSTATZ
    (/usr/bin/rcapstat -z $INTERVAL $COUNT >> $RCAPSTATZ 2>>$ERRORLOG; $ECHO "`$DATE` - ended" >> $RCAPSTATZ)& 
  fi

  Progress 36 $PROGRESSLOOP
  # zpool data
  if [ $MINOR -ge 10 ] && [ -x /usr/sbin/zpool ]
  then
    ZLIST=`/usr/sbin/zpool list | /usr/bin/wc -l`
    if [ $ZLIST -gt 1 ]
    then
      Header "/usr/sbin/zpool iostat $INTERVAL $COUNT" $ZPOOLIOSTAT
      $ECHO "\n\n`$DATE` - started" >> $ZPOOLIOSTAT
      (/usr/sbin/zpool iostat $INTERVAL $COUNT >> $ZPOOLIOSTAT 2>>$ERRORLOG; $ECHO "`$DATE` - ended" >> $ZPOOLIOSTAT)&
    fi
  fi

  Progress 37 $PROGRESSLOOP
  # extra command
  if [ ! -z "$XTRA" ]
  then 
    Header "${XTRA}" xtra.out
    $ECHO "\n\n`$DATE` - started" >> xtra.out
    ${XTRA} >> xtra.out 2>> xtra.err
    $ECHO "`$DATE` - ended" >> xtra.out
  fi 
  Progress 38 $PROGRESSLOOP

  if [ "$QFLAG" -ne 1 ]
  then
    $ECHO  ""
    $ECHO "End Iteration #$ITERATION_COUNT"
    $ECHO "Waiting for processes to terminate then sleeping $WAIT seconds before next iteration."
    $ECHO ""
  fi 

  # wait until all child processes have completed to continue
  wait

  # Start TNF tracing
  if [ "$EXTENDED" -ge 2 ]
  then
    tnf $TNF $ITERATION_COUNT
  fi

  FILENO=`expr $FILENO + 1`
  ITERATIONS=`expr $ITERATIONS - 1`
  ITERATION_COUNT=`expr $ITERATION_COUNT + 1`
  if [ $ITERATIONS -ne 0 ]
  then
    sleep $WAIT
  fi  
done

/usr/bin/cp -p /var/adm/mess* ${DIR} 2>> $ERRORLOG

if [ "$QFLAG" -ne 1 ]
then
  $ECHO "--- All processes finished. ---"
fi

#####################################################################
#####################################################################
#####################################################################

if [ "$QFLAG" -ne 1 ]
then
  $ECHO ""
  $ECHO "Creating tarball...."
fi

cd ${DIR}/..
/usr/bin/chmod a+r *
/usr/bin/tar -cf - $GUDS | /usr/bin/compress | /usr/bin/uuencode $FILE.Z > $FILE.Z.uu
/usr/bin/chmod 666 $FILE.Z.uu
/usr/bin/rm -f $FILE.Z

#####################################################################
#####################################################################
#####################################################################

if [ -n "$FTP" ]
then
  GUDS_FTP=`$ECHO ${FTP} | $NAWK -F/ '{ print $1 }'`
  GUDS_FTPDEST=`$ECHO ${FTP} | /usr/bin/sed -e "s~${GUDS_FTP}~~"`

  # Require host to be in /.netrc
  if [ $ROOT -ne 0 ]
  then
    eval '/usr/bin/egrep -s -e "${GUDS_FTP}" ~/.netrc' 2> /dev/null
  else
    eval '/usr/bin/egrep -s -e "${GUDS_FTP}" /.netrc' 2> /dev/null
  fi

  if [ "$?" -ne 0 ]
  then
    if [ $ROOT -ne 0 ]
    then
      $ECHO "Unable to find ${GUDS_FTP} in ~/.netrc, please update"
    else
      $ECHO "Unable to find ${GUDS_FTP} in /.netrc, please update"
    fi
  else
    # Found in /.netrc, make attempt to ftp
    GUDS_TMPFILE="/var/tmp/ftp.$$"

    /usr/bin/ftp ${GUDS_FTP} >${GUDS_TMPFILE}<<EOF
ascii
cd ${GUDS_FTPDEST}
put ${FILE}.Z.uu
quit
EOF
    /usr/bin/printf "%s sent via ftp to %s\n" ${FILE}.Z.uu ${GUDS_FTP}
  fi
fi

if [ -n "$EMAIL" ]
then
  if [ -x /usr/bin/mailx ]
  then
    if [ -z $SPLIT ]
    then
      SPLIT="10000"
    fi
    /usr/bin/cat ${FILE}.Z.uu | /usr/bin/split -l ${SPLIT} - ${FILE}.Z.uu.
    total=`/usr/bin/ls -1 ${FILE}.Z.uu.* | /usr/bin/wc -l | /usr/bin/sed -e 's/^ *//'`
    if [ "${total}" -gt 1 ]
    then
      filen=1
      for part in ${FILE}.Z.uu.*
      do
        /usr/bin/mailx -s "Case ${CASE} - guds part ${filen}/${total}" ${EMAIL} < ${part}
        /usr/bin/rm ${part}
        filen=`expr $filen + 1`
      done
      /usr/bin/printf "%s sent via mail to %s\n" ${FILE}.Z.uu ${EMAIL}
    else
      /usr/bin/rm ${FILE}.Z.uu.aa
      /usr/bin/mailx -s "Case ${CASE} - guds output" $EMAIL < ${FILE}.Z.uu
      /usr/bin/printf "%s sent via mail to %s\n" ${FILE}.Z.uu ${EMAIL}
    fi
  else
    $ECHO "Unable to find /usr/bin/mailx"
  fi
fi


if [ "$QFLAG" -ne 1 ]
then
  $ECHO "\n\n\n"
  $ECHO "Please send the data to your support engineer."
  $ECHO "The data are stored in ${PDIR}/$CASE/$FILE.Z.uu"
  $ECHO "- You can transfer the file through http, ftp or email."
  $ECHO "- Distinguish the data as from a busy time or idle time by adding"
  $ECHO "  the words busy or idle to the file name."
  $ECHO "\n\n\n"
  $ECHO "Instructions for sending the data through a Web Browser"
  $ECHO "\tGo to URL: https://supportfiles.sun.com"
  $ECHO "\tUnder Step 1, select the file to send"
  $ECHO "\tUnder Step 2, set the destination to: cores"
  $ECHO "\tUnder Step 3, click on Upload" 
  $ECHO "\n\n\n"
  $ECHO "Instructions for uploading a file to supportfiles.sun.com"
  $ECHO "\t# ftp supportfiles.sun.com"
  $ECHO "\t  login: anonymous"
  $ECHO "\t  passwd: your email address"
  $ECHO "\tftp> cd /cores"
  $ECHO "\tftp> ascii"
  $ECHO "\tftp> put $FILE.Z.uu"
  $ECHO "\tftp> bye"
  $ECHO "\n\n\n"
  $ECHO "Instructions for emailing the data"
  $ECHO "\tPut \"Case $CASE\", in the subject line of the email."
  $ECHO "\tAttach the file $FILE.Z.uu to the email."  
  $ECHO ""
  $ECHO "\tThen please call your support engineer or send him an email"
  $ECHO "\tto notify him that the output file is on supportfiles.sun.com."
  $ECHO "\tFor the USA, you can reach your support engineer by phone by"
  $ECHO "\tcalling 1-800USA4SUN, pressing 1, pressing 1, then dialing $CASE"
  $ECHO ""
fi