Article 13472 of alt.sources:

Submitted-by: ljp@tiac.net
Archive-name: orion-1.0/part07

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is `orion.07' (part 7 of orion-1.0).
# Do not concatenate these parts, unpack them in order with `/bin/sh'.
# File `orion-1.0/sargent/sarg_p.h' is being continued...
#
save_IFS="${IFS}"
IFS="${IFS}:"
gettext_dir=FAILED
locale_dir=FAILED
first_param="$1"
for dir in $PATH
do
  if test "$gettext_dir" = FAILED && test -f $dir/gettext \
     && ($dir/gettext --version >/dev/null 2>&1)
  then
    set `$dir/gettext --version 2>&1`
    if test "$3" = GNU
    then
      gettext_dir=$dir
    fi
  fi
  if test "$locale_dir" = FAILED && test -f $dir/shar \
     && ($dir/shar --print-text-domain-dir >/dev/null 2>&1)
  then
    locale_dir=`$dir/shar --print-text-domain-dir`
  fi
done
IFS="$save_IFS"
if test "$locale_dir" = FAILED || test "$gettext_dir" = FAILED
then
  echo=echo
else
  TEXTDOMAINDIR=$locale_dir
  export TEXTDOMAINDIR
  TEXTDOMAIN=sharutils
  export TEXTDOMAIN
  echo="$gettext_dir/gettext -s"
fi
if test ! -r _sh05649/seq; then
  $echo 'Please unpack part 1 first!'
  exit 1
fi
shar_sequence=`cat _sh05649/seq`
if test "$shar_sequence" != 7; then
  $echo 'Please unpack part' "$shar_sequence" 'next!'
  exit 1
fi
if test ! -f _sh05649/new; then
  $echo 'x -' 'STILL SKIPPING' 'orion-1.0/sargent/sarg_p.h'
else
  $echo 'x -' 'continuing file' 'orion-1.0/sargent/sarg_p.h'
  sed 's/^X//' << 'SHAR_EOF' >> orion-1.0/sargent/sarg_p.h &&
X#include<sys/msg.h>
X#include<sys/procfs.h>
X#include<sys/sem.h>
X#include<sys/var.h>
X#include<sys/vfs.h>
X#include<stdio.h>
X#include<dirent.h>
X#include<errno.h>
X#endif
X
X#if defined(SCO5)
X#define _INKERNEL
X#include<sys/types.h>
X/* SCSI and harddrive related. */
X#include<sys/buf.h>
X#include<sys/iobuf.h>
X#include<sys/scsi.h>
X#include<sys/open.h>
X#include<sys/dio.h>
X#include<sys/disk.h>
X#include<sys/Sdsk.h>
X#include<sys/elog.h>
X/* */
X#include<sys/fcntl.h>
X#include<sys/file.h>
X#include<sys/flock.h>
X#include<sys/inode.h>
X#include<sys/mount.h>
X#include<sys/msg.h>
X#include<sys/proc.h>
X#include<sys/region.h>
X#include<sys/sem.h>
X#include<sys/stream.h>
X#include<sys/strstat.h>
X#include<sys/sysi86.h>
X#include<sys/sysinfo.h>
X#undef _INKERNEL
X#include<sys/sysmacros.h>
X#define _INKERNEL
X#include<sys/user.h>
X#include<sys/var.h>
X#include<net/route.h>
X#include<netinet/in.h>
X#include<netinet/in_pcb.h>
X#include<netinet/ip_var.h>
X#include<netinet/udp.h>
X#include<netinet/udp_var.h>
X#include<netinet/tcp.h>
X#include<netinet/tcp_seq.h>
X#include<netinet/tcp_timer.h>
X#include<netinet/tcp_var.h>
X#endif
X
X#include<liborion.h>
X#include<sarg.h>
X
X/*
X** Arguments to usage().
X*/
X#define SARG_USAGE_FULL  0
X#define SARG_USAGE_GOSEE 1
X
X/*
X** Globals.
X*/
Xextern int flagSar;            /* 0=sargent data, 1=sar data.     */
Xextern struct nlist *recNlist; /* Current nlist array.         */
Xextern size_t sizeNlist;       /* Size of current nlist array. */
Xextern struct profile globalProfile;
X
X/*
X** Each define represents a different kernel variable.
X** Using these constants, memAddr() can be called to
X** to determine the kernel address of a given
X** variable.
X*/
X#define SARG_VAR_NULL     0
X#define SARG_VAR_SYSINFO  1
X#define SARG_VAR_MINFO    2
X#define SARG_VAR_INODE    3
X#define SARG_VAR_FILE     4
X#define SARG_VAR_PROC     6
X#define SARG_VAR_FLOCK    7
X#define SARG_VAR_V        8
X#define SARG_VAR_SYSERR   9
X#define SARG_VAR_FREEMEM  10
X#define SARG_VAR_QUEUE    11
X#define SARG_VAR_MBLOCK   12
X#define SARG_VAR_NMBLOCK  13
X#define SARG_VAR_DBLOCK   14
X#define SARG_VAR_MSGINFO  15
X#define SARG_VAR_MSGQUE   16
X#define SARG_VAR_SEMINFO  17
X#define SARG_VAR_MOUNT    18
X#define SARG_VAR_NFSTYP   19
X#define SARG_VAR_FSINFO   20
X#define SARG_VAR_METS     21
X#define SARG_VAR_LOCALPTR 22
X#define SARG_VAR_LOCALOFF 23
X#define SARG_VAR_MODHEAD  24
X#define SARG_VAR_DISKCNT  25
X#define SARG_VAR_SD01DP   26
X#define SARG_VAR_SDSKSTATS 27
X#define SARG_VAR_DSKPROBE  28
X#define SARG_VAR_NDISKS    29
X#define SARG_VAR_DSKSTUFF  30
X#define SARG_VAR_STRSTAT   31
X#define SARG_VAR_ROOTVFS   32
X/*
X** Local metrics ids.
X*/
X#define SARG_VAR_STR      33
X#define SARG_VAR_CPU      34
X#define SARG_VAR_VMMETER  35
X#define SARG_VAR_BUF      36
X#define SARG_VAR_TTY      37
X#define SARG_VAR_SYSCALL  38
X#define SARG_VAR_VM       39
X#define SARG_VAR_KMEM     40
X
X/*
X** Record used in offset table. Maps variable constants
X** with offsets into the sar and sargent nlist arrays.
X*/
Xstruct recOffsets
X{
X    unsigned var;   /* SARG_VAR_* constants.       */
X    off_t sar;      /* Offset in sar nlist array.  */
X    off_t sargent;  /* Offset in sargent nlist array. */
X};
X
X/*
X** Structure of global information.
X*/
Xstruct profile
X{
X    void          *p_scratch;
X    int            p_fdDisk;
X    int            p_fdMem;
X    time_t         p_ts;
X    int            p_cntEngines;
X    unsigned int
X	p_sar      : 1,
X	p_debug    : 1,
X	p_noround  : 1,
X	p_findings : 1;
X
X    struct var  kern_var;
X#if defined(ORION_FEAT_METRICS)
X    struct mets kern_mets;
X#endif
X};
X
Xstruct sampEntry
X{
X    int (*s_sample)(int);
X    int (*s_init)(int);
X    const char *s_name;
X};
X
X/*
X** String table.
X*/
Xextern const char * const S_Empty;
Xextern const char * const S_PathMem;
Xextern const char * const S_PathSa;
Xextern const char * const S_PathLsa;
Xextern const char * const S_PathAddr;
Xextern const char * const S_PathLaddr;
Xextern const char * const S_PathKern;
Xextern const char * const S_PrefixSa;
Xextern const char * const S_PrefixLsa;
Xextern const char * const S_Command;
X#if defined(SVR4) || defined(UW2) || defined(SUN5)
Xextern const char * const S_PathProc;
X#endif
X#ifdef WOLLONG32
Xextern const char * S_SymEstrms;
X#endif
Xextern const char * S_SymDummy;
X
Xextern const unsigned C_IntervalTime;
Xextern const unsigned C_IntervalCount;
X
Xextern const int C_MaxNlist;
Xextern const int C_MaxLnlist;
X
Xextern pid_t pids[];
X
Xextern int diskInit( int );
Xextern int mountInit( int );
Xextern int netstatInit( int );
Xextern int procInit( int, int );
Xextern int streamsInit( int );
X#ifdef WOLLONG32
Xextern int wollongInit( int );
X#endif
X#ifdef VENIX32
Xextern int venixInit( int );
X#endif
X#if defined(VENIX32)
Xextern int sampleSar( struct sa*, int, caddr_t );
X#endif
Xextern int basic1Sample( int );
Xextern int procSample( int, int );
Xextern int basic1Sample( int );
Xextern int diskSample( int );
Xextern int ipcsSample( int );
Xextern int psSample( int );
Xextern int mountSample( int );
Xextern int tcpipSample( int );
Xextern int netstatSample( int );
Xextern int streamsSample( int );
Xextern int ttySample( int );
Xextern int memsysSample( int );
Xextern int moduleSample( int );
X#ifdef VENIX32
Xextern int venixSample( int );
X#endif
X#ifdef WOLLONG32
Xextern int wollongSample( int );
X#endif
X/*
X** Kernel access subsystem.
X*/
Xextern int memInit( void );
Xextern int memFetch( unsigned, void*, unsigned );
Xextern int memRead( int, caddr_t, void*, unsigned );
Xextern caddr_t memAddr( unsigned );
X#if defined(ORION_FEAT_METRICS)
Xextern int metInit( void );
Xextern void *metFetch( unsigned );
X#endif
X#if defined(ORION_FEAT_SYSINFO)
Xextern void siReset( void );
Xextern void *siFetch( unsigned );
X#endif
X
Xextern int procAdd( pid_t );
Xextern int diskWrite( void*, unsigned, unsigned );
X
X#endif
SHAR_EOF
  $echo 'File' 'orion-1.0/sargent/sarg_p.h' 'is complete' &&
  chmod 0664 'orion-1.0/sargent/sarg_p.h' ||
  $echo 'restore of' 'orion-1.0/sargent/sarg_p.h' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/sarg_p.h:' 'MD5 check failed'
ff77cebed5e3e1fc3c2a2cd9daeaa255  orion-1.0/sargent/sarg_p.h
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/sarg_p.h'`"
    test 6784 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/sarg_p.h:' 'original size' '6784,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/sarg.c ==============
if test -f 'orion-1.0/sargent/sarg.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/sarg.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/sarg.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/sarg.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#include"sarg_p.h"
X
Xstatic caddr_t allocScratch( void );
Xstatic void usage( unsigned );
X
X/*
X** Ordered by type. So this table should always have
X** SARG_MAX_RTYP entries.
X*/
Xstruct sampEntry sampTable[] =
X{
X    { NULL,          NULL,        NULL        },
X    { basic1Sample,  NULL,        "Basic1"    },
X    { NULL,          NULL,        "Reboot"    },
X    { procSample,    procInit,    "Proc"      },
X#ifdef WOLLONG32
X    { wollongSample, wollongInit, "Wollong"   },
X#else
X    { NULL,          NULL,        NULL        },
X#endif
X    { netstatSample, netstatInit, "Netstat"   },
X    { mountSample,   mountInit,   "Mount"     },
X    { psSample,      NULL,        "Ps"        },
X    { ipcsSample,    NULL,        "Ipcs"      },
X#ifdef VENIX32
X    { venixSample,   venixInit,   "VENIX"     },
X#else
X    { NULL,          NULL,        NULL        },
X#endif
X    { streamsSample, streamsInit, "STREAMS"   },
X    { ttySample,     NULL,        "TTY"       },
X    { memsysSample,  NULL,        "Memsys"    },
X#if defined(SVR4) || defined(UW2)
X    { moduleSample,  NULL,        "Module"    },
X#else
X    { NULL,          NULL,        NULL        },
X#endif
X    { diskSample,    diskInit,    "Disk"      }
X};
X
X/*
X** Globals.
X*/
X
X/*
X** String table.
X*/
Xconst char * const S_Empty       = "";
Xconst char * const S_PathMem     = "/dev/kmem";
Xconst char * const S_PathSa      = "/usr/adm/sa";
Xconst char * const S_PathLsa     = "/usr/adm/sa";
Xconst char * const S_PathAddr    = "/tmp/sa.adrfl";
Xconst char * const S_PathLaddr   = "/tmp/ssa.adrfl";
X#if defined(SVR4) || defined(UW2) || defined(SCO5)
Xconst char * const S_PathKern    = "/stand/unix";
X#endif
X#if defined(VENIX32) || defined(SVR3)
Xconst char * const S_PathKern    = "/unix";
X#endif
X#if defined(SUN5)
Xconst char * const S_PathKern    = "/kernel/unix";
X#endif
X#if defined(ORION_FEAT_PROCFS)
Xconst char * const S_PathProc    = "/proc";
X#endif
Xconst char * const S_PrefixSa    = "sa";
Xconst char * const S_PrefixLsa   = "ssa";
Xconst char * const S_Command     = "sargent";
Xconst char * const S_VerDbg      = SARG_STR_VER;
Xconst char * const S_RcsHeader   = "$Header: /home2/ljp/src/src-ljp/product/orion/sargent/sarg.c,v 1.5 1996/06/24 06:15:08 ljp Exp $";
X
Xconst unsigned C_IntervalTime  = 10;
Xconst unsigned C_IntervalCount = 1;
X
Xstruct profile globalProfile;
Xchar           globalEnable[SARG_MAX_RTYP+1];
X
Xmain( int argc, const char *argv[] )
X{
X    char pathData[1023+1];
X    const char *strTimeBegin, *strTimeEnd;
X    int fdMem, fdData;
X    int i;
X    int flagReboot, flagAllday, flagLock, flagPriority;
X    unsigned countInterval, timeInterval;
X    unsigned priority;
X    time_t timeWait, timeEnd;
X    void *scratch;
X
X    /*
X    ** Global flag, determining whether sar or Sargent data
X    ** is being used. Can be adjusted through command line.
X    */
X    globalProfile.p_sar = 0;
X
X    /*
X    ** Global flag determinig whether or not debug output
X    ** is written to standard out. Can be adjusted through
X    ** the command line.
X    */
X    globalProfile.p_debug = 0;
X
X    /*
X    ** By default, when a starting time is not given, sampling begins
X    ** at the "top" of the next interval. A command line option can
X    ** be used to disable this. For example, if the interval is one
X    ** hour, it may not be desirable to wait for the next hour to
X    ** begin before sampling.
X    */
X    globalProfile.p_noround = 0;
X
X    /*
X    ** Indicate that the kernel mets structure has not yet
X    ** been read in.
X    */
X#if defined(ORION_FEAT_METRICS)
X    globalProfile.kern_mets.mets_native_units.mnu_hz = 0;
X#endif
X
X    /*
X    ** VENIX version can lock itself in core and change
X    ** real time priorities.
X    */
X#ifdef VENIX32
X    flagLock = 0;
X    flagPriority = 0;
X    priority = RT_PRI_LOW;
X#endif
X
X    /*
X    ** Start and end times for sample collection.
X    */
X    strTimeBegin = strTimeEnd = NULL;
X
X    /*
X    ** Number of samples and seconds between samples.
X    */
X    countInterval = timeInterval = 0;
X
X    /*
X    ** File where sample data is placed.
X    */
X    pathData[0] = '\0';
X
X    /*
X    ** Number of seconds to wait before sampling starts.
X    */
X    timeWait = 0;
X
X    /*
X    ** List of process ids.
X    */
X    for( i=0; i<SARG_MAX_PROCS; ++i )
X	pids[i] = -1;
X
X    /*
X    */
X    for( i=0; i<SARG_MAX_RTYP+1; ++i )
X	globalEnable[i] = 0;
X
X    /*
X    ** Enable Basic1 records by default.
X    */
X    globalEnable[SARG_RTYP_BASIC1] = 1;
X
X    /*
X    ** Loop through all command line arguments.
X    */
X    for( i=1; i<argc; ++i )
X    {
X	if( !strcmp("-f",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-f\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    strcpy( pathData, argv[i] );
X	    continue;
X	}
X	if( !strcmp("-s",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-s\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    strTimeBegin = argv[i];
X	    continue;
X	}
X	if( !strcmp("-e",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-e\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    strTimeEnd = argv[i];
X	    continue;
X	}
X	if( !strcmp("-c",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-c\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    countInterval = atoi( argv[i] );
X	    continue;
X	}
X	if( !strcmp("-t",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-t\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    timeInterval = atoi( argv[i] );
X	    continue;
X	}
X	if( !strcmp("-p",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-p\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    procAdd( (pid_t)atoi(argv[i]) );
X	    continue;
X	}
X	if( !strcmp("-prio",argv[i]) )
X	{
X	    ++i;
X	    if( i >= argc )
X	    {
X		fputs( "Need argument to \"-prio\".\n", stdout );
X		usage( SARG_USAGE_GOSEE );
X		exit( 1 );
X	    }
X	    ++flagPriority;
X	    priority = atoi( argv[i] );
X	    continue;
X	}
X	if( !strcmp("-sar",argv[i]) )
X	{
X#if defined(VENIX32) || defined(SVR3) || defined(SVR4)
X	    globalProfile.p_sar = 1;
X	    continue;
X#endif
X#if defined(UW2)
X	    fputs( "UnixWare 2 version does not support sar data.\n",
X		stdout );
X	    exit( 1 );
X#endif
X	}
X	if( !strcmp("-v",argv[i]) )
X	{
X	    fputs( "Debugging on.\n", stdout );
X	    globalProfile.p_debug = 1;
X	    continue;
X	}
X	if( !strcmp("-V",argv[i]) )
X	{
X	    globalProfile.p_findings = 1;
X	    continue;
X	}
X	if( !strcmp("-reboot",argv[i]) )
X	{
X	    ++flagReboot;
X	    continue;
X	}
X	if( !strcmp("-lock",argv[i]) )
X	{
X#ifndef VENIX32
X	    fputs( "Only VENIX 3.2 version can lock itself.\n", stdout );
X	    continue;
X#else
X	    ++flagLock;
X	    continue;
X#endif
X	}
X	if( !strcmp("-noround",argv[i]) )
X	{
X	    globalProfile.p_noround = 1;
X	    continue;
X	}
X	if( !strcmp("-allday",argv[i]) )
X	{
X	    ++flagAllday;
X	    continue;
X	}
X	if( !strcmp("-wollong",argv[i]) )
X	{
X#ifndef WOLLONG32
X	    fputs( "Wollongong SVR3 driver support was not built.\n",
X		stdout );
X	    continue;
X#else
X	    globalEnable[SARG_RTYP_WOLLONG] = 1;
X	    continue;
X#endif
X	}
X	if( !strcmp("-venix",argv[i]) )
X	{
X#ifndef VENIX32
X	    fputs( "VENIX 3.2 support was not built.\n",
X		stdout );
X	    continue;
X#else
X	    globalEnable[SARG_RTYP_VENIX] = 1;
X	    continue;
X#endif
X	}
X	if( !strcmp("-memsys",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_MEMSYS] = 1;
X	    continue;
X	}
X	if( !strcmp("-disk",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_DISK] = 1;
X	    continue;
X	}
X	if( !strcmp("-module",argv[i]) )
X	{
X#if defined(SVR4) || defined(UW2)
X	    globalEnable[SARG_RTYP_MODULE] = 1;
X#else
X	    fputs( "Module record type not supported on this platform.\n",
X		stdout );
X#endif
X	    continue;
X	}
X	if( !strcmp("-mount",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_MOUNT] = 1;
X	    continue;
X	}
X	if( !strcmp("-ps",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_PS] = 1;
X	    continue;
X	}
X	if( !strcmp("-netstat",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_NETSTAT] = 1;
X	    continue;
X	}
X	if( !strcmp("-ipcs",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_IPCS] = 1;
X	    continue;
X	}
X	if( !strcmp("-streams",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_STREAMS] = 1;
X	    continue;
X	}
X	if( !strcmp("-tty",argv[i]) )
X	{
X	    globalEnable[SARG_RTYP_TTY] = 1;
X	    continue;
X	}
X	if( !strcmp("-help",argv[i]) || !strcmp("-?",argv[i]) )
X	{
X	    usage( SARG_USAGE_FULL );
X	    continue;
X	}
X	if( !strcmp("-ver",argv[i]) || !strcmp("-?",argv[i]) )
X	{
X	    fprintf( stdout, "Version of Orion is %s.\n", S_VerDbg );
X	    exit( 0 );
X	}
X	if( argv[i][0] == '-' )
X	{
X	    fprintf( stdout, "Unrecognized option, \"%s\".\n", argv[i] );
X	    usage( SARG_USAGE_GOSEE );
X	    exit( 1 );
X	}
X	fprintf( stdout, "Unrecognized argument, \"%s\".\n", argv[i] );
X	usage( SARG_USAGE_GOSEE );
X	exit( 1 );
X    }
X
X    /*
X    ** Rationalize the command line settings.
X    */
X
X    /*
X    ** When sampling until the end of the day, both a count and a
X    ** time interval cannot be used.
X    */
X    if( flagAllday && countInterval && timeInterval )
X    {
X	fputs(
X	    "When using \"-allday\", can not specify both count and"
X	    " interval.\n",
X	    stdout );
X	usage( SARG_USAGE_GOSEE );
X	exit( 1 );
X    }
X
X    /*
X    ** When writing a marker, can not perform sampling.
X    */
X    if( flagReboot && (flagAllday||countInterval||timeInterval) )
X    {
X	fputs( "Can not use any options with \"-reboot\".\n", stdout );
X	usage( SARG_USAGE_GOSEE );
X	exit( 1 );
X    }
X
X    /*
X    ** If sampling until the end of the day and neither a count of
X    ** samples nor a time between samples was given, use the default
X    ** time between samples (the other will be calculated).
X    */
X    if( flagAllday && !countInterval && !timeInterval )
X	timeInterval = C_IntervalTime;
X
X    /*
X    ** If not sampling until the end of the day, make sure that both
X    ** the count of samples and the time between samples have values.
X    */
X    if( !flagAllday && !flagReboot && !countInterval )
X	countInterval = C_IntervalCount;
X    if( !flagAllday && !flagReboot && !timeInterval )
X	timeInterval = C_IntervalTime;
X
X    /*
X    ** According to the sar(1M) man page, intervals under five
X    ** seconds affect the data. This probably ought to be a
X    ** little higher.
X    */
X    if( !flagReboot && timeInterval<5 )
X    {
X	fputs( "Interval time cannot be less than 5 seconds.\n", stdout );
Xfprintf( stdout, "Interval is %d.\n", timeInterval );
X	usage( SARG_USAGE_GOSEE );
X	exit( 1 );
X    }
X
X    /*
X    ** If no filename was given to receive the sample data, create
X    ** one using the default naming scheme.
X    */
X    if( pathData[0] == '\0' )
X    {
X	time_t timeCurr;
X	struct tm *recTimeCurr;
X
X	timeCurr = time( NULL );
X	recTimeCurr = localtime( &timeCurr );
X
X	sprintf( pathData, "%s/%s%.2d",
X	    globalProfile.p_sar?S_PathSa:S_PathLsa,
X	    globalProfile.p_sar?S_PrefixSa:S_PrefixLsa,
X	    recTimeCurr->tm_mday );
X    }
X
X    if( globalProfile.p_findings )
X    {
X	fprintf( stdout, "size of struct nlist is %d.\n",
X	    sizeof(struct nlist) );
X	fprintf( stdout, "size of struct proc is %d.\n",
X	    sizeof(struct proc) );
X#if defined(VENIX32) || defined(SVR3) || defined(SVR4)
X	fprintf( stdout, "size of struct sa is %d.\n",
X	    sizeof(struct sa) );
X#endif
X	if( !(globalProfile.p_sar) )
X	{
X	    fprintf( stdout, "size of struct sargBasic1 is %d.\n",
X		sizeof(struct sargBasic1) );
X	    fprintf( stdout, "size of struct sargProc is %d.\n",
X		sizeof(struct sargProc) );
X	}
X    }
X
X    /*
X    ** Initialize kernel structure address lookup and caching
X    ** routines.
X    */
X    if( !memInit() )
X	exit( 1 );
X    fdMem = globalProfile.p_fdMem;
X
X    /*
X    ** Append to the data file.
X    */
X    if( (fdData=open(pathData,O_WRONLY|O_APPEND|O_CREAT|O_SYNC,0644)) == -1 )
X    {
X	close( fdMem );
X	fprintf( stdout, "Bad open(2) of \"%s\" (sample data). %s.\n",
X	    pathData, sys_errlist[errno] );
X	exit( 1 );
X    }
X    globalProfile.p_fdDisk = fdData;
X
X    /*
X    ** Allocate scratch pad memory.
X    **
X    ** Populate the global copy of the kernel var structure.
X    */
X    if( (scratch=allocScratch()) == NULL )
X    {
X	close( fdData );
X	close( fdMem );
X	exit( 1 );
X    }
X    globalProfile.p_scratch = scratch;
X
X    /*
X    ** Call the initialization routines for each
X    ** enabled sample type.
X    */
X    for( i=0; i<SARG_MAX_RTYP+1; ++i )
X    {
X	if( !globalEnable[i] || sampTable[i].s_init==NULL )
X	    continue;
X	globalEnable[i] = sampTable[i].s_init( fdMem );
X    }
X    for( i=0; i<SARG_MAX_PROCS; ++i )
X    {
X	if( pids[i] == -1 )
X	    continue;
X	procInit( fdMem, i );
X    }
X
X#ifdef VENIX32
X    if( flagPriority )
X    {
X	if( rtpriority(RT_PRI_SET,priority) == -1 )
X	{
X	    fprintf( stdout, "Bad rtpriority(). %s.\n", sys_errlist[errno] );
X	    exit( 1 );
X	}
X	if( globalProfile.p_debug )
X	{
X	    fprintf( stdout, "Real time priority set to %d.\n",
X		priority );
X	}
X    }
X#endif
X
X#ifdef VENIX32
X    if( flagLock )
X    {
X	if( rtlock(RT_LOCK,0,0) == -1 )
X	{
X	    fprintf( stdout, "Bad rtlock(). %s.\n", sys_errlist[errno] );
X	    exit( 1 );
X	}
X    }
X#endif
X
X    /*
X    ** Calculate the following.
X    **
X    ** timeWait.      Seconds to wait before sampling starts.
X    ** timeInterval.  Seconds between samples.
X    ** countInterval. Number of samples to make.
X    **
X    ** The following variables are used:
X    **
X    ** timeCurr.      Abs current time.
X    ** timeNow.       Seconds from start of day to current time.
X    ** timeBegin.     Seconds from start of day to start of sampling.
X    ** timeEnd.       Abs time at which sampling should end.
X    */
X    {
X	int hour, min, sec;
X	time_t timeCurr, timeNow, timeBegin;
X	struct tm *recTimeCurr;
X
X	timeWait = 0;
X
X	/*
X	** Fetch absolute time from UNIX.
X	*/
X	timeCurr = time( NULL );
X
X	/*
X	** Decompose into hours, minutes and seconds.
X	*/
X	recTimeCurr = localtime( &timeCurr );
X
X	/*
X	** Determine number of seconds from start of today.
X	*/
X	timeNow = (recTimeCurr->tm_hour*3600) + (recTimeCurr->tm_min*60) +
X	    recTimeCurr->tm_sec;
X
X	/*
X	** If a start time was given, determine the number of seconds to
X	** wait before it comes around. Note that rounding of start time
X	** will not take place.
X	*/
X	if( strTimeBegin != NULL )
X	{
X	    hour = min = sec = 0;
X	    sscanf( strTimeBegin, "%d:%d:%d", &hour, &min, &sec );
X	    timeBegin = (time_t)(sec+(min*60)+(hour*3600));
X	    if( timeNow < timeBegin )
X		timeWait = timeBegin - timeNow;
X	}
X
X	/*
X	** If an end time was given, determine the number of samples
X	** need to cover this time. Note that "-allday" can not have
X	** been given (checked for above).
X	*/
X	if( strTimeEnd != NULL )
X	{
X	    hour = min = sec = 0;
X	    sscanf( strTimeEnd, "%d:%d:%d", &hour, &min, &sec );
X	    timeEnd = (time_t)(sec+(min*60)+(hour*3600));
X	    if( timeEnd<timeNow || timeEnd<(timeCurr+timeWait) )
X	    {
X		fputs( "End time has passed or is before begin time.\n",
X		    stdout );
X		free( scratch );
X		close( fdData );
X		close( fdMem );
X		exit( 1 );
X	    }
X	}
X
X	if( flagAllday )
X	    timeEnd = 60 * 60 * 24;
X
X	/*
X	** End sampling at the end of the day. "-e" can not have been
X	** given (checked for above). If either an interval time or
X	** sampling count is given, the other is adjusted so that the
X	** remainder of the day is covered.
X	*/
X	if( timeEnd )
X	{
X#if 0
X	    /*
X	    ** Do not continue if 11:30pm or greater.
X	    */
X	    if( timeNow >= (22*3600)+(30*60) )
X	    {
X		fputs( "Too close to midnight for \"-allday\".\n", stdout );
X		free( scratch );
X		close( fdData );
X		close( fdMem );
X		exit( 0 );
X	    }
X#endif
X
X	    sec = timeEnd - timeNow;
X
X	    if( timeInterval )
X		countInterval = sec / timeInterval;
X	    else
X	    {
X		timeInterval = sec / countInterval;
X		if( timeInterval < 5 )
X		{
X		    fputs( "Interval time cannot be less than 5 seconds.\n",
X			stdout );
X		    free( scratch );
X		    close( fdData );
X		    close( fdMem );
X		    exit( 0 );
X		}
X	    }
X	}
X
X	/*
X	** Wait for the "top" of the next interval. For example, if
X	** the interval is 5 seconds and the current time is
X	** 13:08:08, wait for 13:08:05.
X	**
X	** Do not do this if "-noround" or "-s" are specified.
X	*/
X	if( strTimeBegin==NULL && !(globalProfile.p_noround) )
X	{
X	    timeWait = timeInterval -
X		(timeNow-((timeNow/timeInterval)*timeInterval));
X	    if( timeWait >= timeInterval )
X		timeWait = 0;
X	}
X
X	if( globalProfile.p_debug )
X	{
X	    fprintf( stdout, "%d samples. %d seconds before starting.\n",
X		countInterval, timeWait );
X	}
X    }
X
X    /*
X    ** Finally. Perform the given number of samples at the
X    ** given interval.
X    */
X    {
X	int i;
X	void *proc;
X	unsigned interval;
X#if defined(VENIX32) || defined(SVR3) || defined(SVR4)
X	struct sa recSar;
X#endif
X
X	if( timeWait )
X	    sleep( timeWait );
X
X	if( globalProfile.p_debug )
X	{
X	    fprintf( stdout, "Making %d samples, %d seconds apart.\n",
X		countInterval, timeInterval );
X	}
X	for( interval=0; interval<countInterval; ++interval )
X	{
X	    /*
X	    ** Time of sample. This time will be used for all samples
X	    ** in this iteration.
X	    */
X	    time( &(globalProfile.p_ts) );
X
X	    /*
X	    ** Take a sar(1M) style sample if that is what is
X	    ** called for.
X	    */
X#if defined(VENIX32) || defined(SVR3) || defined(SVR4)
X	    if( globalProfile.p_sar )
X	    {
X		(void)sampleSar( &recSar, fdMem, scratch );
X		write( fdData, &recSar, sizeof(recSar) );
X	    }
X	    /*
X	    ** Take an Sargent style sample.
X	    */
X	    else
X#endif
X	    {
X		/*
X		** Reset kernel structures caches.
X		*/
X#ifdef ORION_FEAT_SYSINFO
X		siReset();
X#endif
X		/*
X		** Call the sample routine for each enabled type.
X		*/
X		for( i=0; i<SARG_MAX_RTYP+1; ++i )
X		{
X		    if( globalEnable[i] && sampTable[i].s_sample!=NULL )
X			(void*)sampTable[i].s_sample( fdMem );
X		}
X
X		/*
X		** Do the "proc" samples.
X		*/
X#if defined(ORION_FEAT_PROCTAB)
X		/* Re-read the process table. */
X		procReset();
X#endif
X		for( i=0; i<SARG_MAX_PROCS; ++i )
X		{
X		    if( pids[i] == -1 )
X			continue;
X
X		    if( !procSample(fdMem,i) )
X		    {
X			if( globalProfile.p_debug )
X			{
X			    fprintf( stdout, "Bad sample of pid %d.\n",
X				pids[i] );
X			}
X			continue;
X		    }
X		}
X	    }
X
X	    /* Avoid last sleep. */
X	    if( interval >= countInterval )
X		break;
X
X	    /* Wait for next sampling time. */
X	    sleep( timeInterval );
X	}
X    }
X
X    free( scratch );
X    close( fdData );
X    close( fdMem );
X    exit( 0 );
X}
X
X/*
X** allocScratch()
X**
X** Currently this function works for both sar and Sargent data.
X*/
Xstatic caddr_t allocScratch( void )
X{
X    caddr_t ptr;
X    size_t max;
X
X    max = 0;
X
X    if( !memFetch(SARG_VAR_V,(void*)&globalProfile.kern_var,
X	sizeof(globalProfile.kern_var)) )
X    {
X	fputs( "Could not fetch \"var\".\n", stdout );
X	return NULL;
X    }
X
X#if !defined(UW2)
X    {
X	int nmblock;
X	struct msginfo msginfo;
X
X	if( !memFetch(SARG_VAR_NMBLOCK,(void*)&nmblock,sizeof(nmblock)) )
X	{
X	    fputs( "Could not fetch \"nmblock\".\n", stdout );
X	    return NULL;
X	}
X	max = maximum( max, nmblock, sizeof(mblk_t) );
X
X	if( !memFetch(SARG_VAR_MSGINFO,(void*)&msginfo,
X	    sizeof(struct msginfo)) )
X	{
X	    fputs( "Could not fetch \"msginfo\".\n", stdout );
X	    return NULL;
X	}
X	max = maximum( max, msginfo.msgmni, sizeof(struct msqid_ds) );
X
X	max = maximum( max, globalProfile.kern_var.v_proc,
X	    sizeof(struct proc) );
X	max = maximum( max, globalProfile.kern_var.v_inode,
X	    sizeof(struct inode) );
X	max = maximum( max, globalProfile.kern_var.v_file,
X	    sizeof(struct file) );
X	max = maximum( max, globalProfile.kern_var.v_nqueue,
X	    sizeof(struct queue) );
X	max = maximum( max, globalProfile.kern_var.v_mount,
X	    sizeof(struct mount) );
X    }
X#endif
X
X#if defined(UW2)
X    max = maximum( max, 1, sizeof(struct pstatus) );
X#endif
X
X#if defined(SVR4) || defined(UW2) || defined(SUN5)
X    {
X	struct sargModule sargModule;
X
X	max = maximum( max, 64, sizeof(sargModule.loaded[0]) );
X    }
X#endif
X
X    if( globalProfile.p_debug )
X	fprintf( stdout, "Allocating %d bytes for scratch.\n", max );
X
X    if( (ptr=(caddr_t)malloc(max)) == NULL )
X    {
X	fputs( "Bad malloc(3).\n", stdout );
X	return NULL;
X    }
X
X    return ptr;
X}
X
Xint diskWrite( void *buf, unsigned len, unsigned type )
X{
X    int rc;
X    struct sargHdr recHdr;
X
X    recHdr.h_type = type;
X    recHdr.h_ts = globalProfile.p_ts;
X    recHdr.h_len = len;
X    if( (rc=write(globalProfile.p_fdDisk,&recHdr,sizeof(recHdr))) == -1 )
X    {
X	fprintf( stdout, "Bad write(). %s.\n", sys_errlist[errno] );
X	return 0;
X    }
X    if( rc != sizeof(recHdr) )
X    {
X	fprintf( stdout, "Bad write(). Only wrote %d of %d.\n", rc, len );
X	return 0;
X    }
X
X    if( (rc=write(globalProfile.p_fdDisk,buf,len)) == -1 )
X    {
X	fprintf( stdout, "Bad write(). %s.\n", sys_errlist[errno] );
X	return 0;
X    }
X    if( rc != len )
X    {
X	fprintf( stdout, "Bad write(). Only wrote %d of %d.\n", rc, len );
X	return 0;
X    }
X
X    return 1;
X}
X
Xstatic void usage( unsigned type )
X{
X    if( type == SARG_USAGE_GOSEE )
X    {
X	fprintf( stdout,
X	    "Use \"%s -help\" or \"%s -?\" for details.\n",
X	    S_Command, S_Command );
X	return;
X    }
X
X    fprintf( stdout,
X	"usage: %s [-s <time>][-e <time>][-f <file>]\n",
X	S_Command );
X    fputs(
X	"\t-s  Time (today) to start collecting.\n",
X	stdout );
X    fputs(
X	"\t-e  Time (today) to stop collecting.\n",
X	stdout );
X    fputs(
X	"\t-f  Filename to store data in.\n",
X	stdout );
X    fputs(
X	"\t-c  Specify number of samples.\n",
X	stdout );
X    fputs(
X	"\t-t  Specify seconds between samples.\n",
X	stdout );
X    fputs(
X	"\t-allday Sample until the end of the day.\n",
X	stdout );
X    fputs(
X	"\t-mark   Just write a marker to the data file.\n",
X	stdout );
X    fputs(
X	"\t-sar    Collect sar data instead of sargent data.\n",
X	stdout );
X    fputs(
X	"\t-noround Do not round start time to nearest internal.\n",
X	stdout );
X    fputs(
X	"\t-v      Print debug information.\n",
X	stdout );
X    fputs(
X	"+ Times are specified as HH:MM:SS, HH:MM or HH.\n",
X	stdout );
X}
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/sarg.c' ||
  $echo 'restore of' 'orion-1.0/sargent/sarg.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/sarg.c:' 'MD5 check failed'
37952fb4c61caaea8ae1588f5eadbcb7  orion-1.0/sargent/sarg.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/sarg.c'`"
    test 22433 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/sarg.c:' 'original size' '22433,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/disk.c ==============
if test -f 'orion-1.0/sargent/disk.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/disk.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/disk.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/disk.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#include"sarg_p.h"
X
Xstatic int cntDisks;
X#if defined(SCO5) || defined(SCO4)
Xstatic char disk_names[SARG_MAX_DISKS][SARG_MAX_DISKNAME+1];
X#endif
X
X/*
X** diskInit()
X*/
Xint diskInit( int fd )
X{
X#if defined(SCO4) || defined(SCO5)
X    /*
X    ** Only the Sdsk driver is supported.
X    */
X    {
X	int i;
X	int *probe;
X	Sdsk_stuff *stuff;
X	DEVCFG cfg;
X
X	/*
X	** Get the number of disk allocated.
X	*/
X	if( !memFetch(SARG_VAR_NDISKS,&cntDisks,sizeof(int)) )
X	{
X	    fputs( "Can not fetch \"Sdsk_num_disks\".\n", stdout );
X	    return 0;
X	}
X
X	/*
X	** Get the array of disks found on system.
X	*/
X	if( !memRead(globalProfile.p_fdMem,memAddr(SARG_VAR_DSKPROBE),
X	    globalProfile.p_scratch,sizeof(int)*cntDisks) )
X	{
X	    fputs( "Can not fetch \"SdskProbe[]\".\n", stdout );
X	    return 0;
X	}
X	probe = (int*)globalProfile.p_scratch;
X	for( cntDisks=0; probe[cntDisks]!=0; ++cntDisks );
X
X	if( globalProfile.p_debug )
X	    fprintf( stdout, "Detected %d SCSI disks.\n", cntDisks );
X
X	/*
X	** Get the array of disk records.
X	*/
X	if( !memRead(globalProfile.p_fdMem,memAddr(SARG_VAR_DSKSTUFF),
X	    globalProfile.p_scratch,sizeof(Sdsk_stuff)*cntDisks) )
X	{
X	    fputs( "Can not fetch \"Sdsk_stuff[]\".\n", stdout );
X	    return 0;
X	}
X	stuff = (Sdsk_stuff*)globalProfile.p_scratch;
X
X	/*
X	** Get the SCSI record for each disk.
X	*/
X	for( i=0; i<cntDisks; ++i )
X	{
X	    if( !memRead(globalProfile.p_fdMem,(caddr_t)stuff[i].cfg_p,
X		(void*)&cfg,sizeof(cfg)) )
X	    {
X		fputs( "Can not fetch \"DEVCFG\" record.\n", stdout );
X		return 0;
X	    }
X	    /*
X	    ** FUTURE: What about the bus number? (SCSI cards with
X	    ** more than one SCSI bus).
X	    */
X	    sprintf( disk_names[i], "Sdsk%d c%db?t%dd%d",
X		i, cfg.ha_num, cfg.id, cfg.lun );
X	}
X    }
X#endif
X
X    /*
X    ** All other platforms either figure it out each sample, or do
X    ** not collect per-disk data.
X    */
X#if !defined(SCO5) && !defined(SCO4)
X    cntDisks = -1;
X#endif
X}
X
X/*
X** diskSample()
X**
X*/
Xint diskSample( int fdMem )
X{
X    int i;
X    struct sargDisk sargDisk;
X
X    if( globalProfile.p_debug )
X	fputs( "Making disk sample.\n", stdout );
X
X    sargDisk.cntDisks = cntDisks;
X
X#if defined(ORION_FEAT_SYSINFO)
X    {
X	struct sysinfo *si;
X
X	si = siFetch( SARG_VAR_SYSINFO );
X
X	sargDisk.cntReadBuf = si->bread;
X	sargDisk.cntWriteBuf = si->bwrite;
X	sargDisk.cntReadLogic = si->lread;
X	sargDisk.cntWriteLogic = si->lwrite;
X	sargDisk.cntReadPhys = si->phread;
X	sargDisk.cntWritePhys = si->phwrite;
X    }
X#endif
X
X#if defined(SCO5)
X    /*
X    ** Only the Sdsk driver is supported.
X    */
X    {
X	struct iotime *stat;
X
X	stat = (struct iotime*)globalProfile.p_scratch;
X
X	if( cntDisks > 0 )
X	{
X	    for( i=0; i<cntDisks; ++i )
X	    {
X		strcpy( sargDisk.disks[i].name, disk_names[i] );
X		if( !memFetch(SARG_VAR_SDSKSTATS,(void*)stat,
X		    sizeof(struct iotime)*cntDisks) )
X		{
X		    fputs( "Could not fetch \"Sdskstats\".\n", stdout );
X		    break;
X		}
X		sargDisk.disks[i].qlen = stat->ios.io_qcnt;
X		sargDisk.disks[i].resp.dl_lop = (long)stat->io_resp;
X		sargDisk.disks[i].active.dl_lop = (long)stat->io_act;
X		sargDisk.disks[i].cntRW = stat->ios.io_ops;
X		sargDisk.disks[i].cntBRW = stat->io_bcnt;
X	    }
X	}
X    }
X#endif
X
X#if defined(UW2)
X    /*
X    ** UnixWare 2 disk metrics. This data seems to be more part of
X    ** the sd01 driver than the general metrics facility.
X    */
X    {
X	struct disk **disk_p;
X	struct disk disk;
X	struct met_disk_stats stat;
X
X	if( !memFetch(SARG_VAR_DISKCNT,&cntDisks,sizeof(int)) )
X	{
X	    fprintf( stdout, "Could not fetch \"sd01_diskcnt\". %s.\n",
X		sys_errlist[errno] );
X	    return 0;
X	}
X
X	if( globalProfile.p_findings )
X	    fprintf( stdout, "sd01_diskcnt is %d.\n", cntDisks );
X
X	sargDisk.cntDisks = cntDisks;
X
X	if( !memRead(globalProfile.p_fdMem,memAddr(SARG_VAR_SD01DP),
X	    globalProfile.p_scratch,sizeof(struct disk*)*(cntDisks+1)) )
X	{
X	    fputs( "Could not read sd01_dp[] table.\n", stdout );
X	    return 0;
X	}
X
X	disk_p = (struct disk **)globalProfile.p_scratch;
X
X	/*
X	** FUTURE: The array elements are offset by one entry.
X	*/
X	for( i=1; i<(cntDisks+1); ++i )
X	{
X	    if( !memRead(globalProfile.p_fdMem,(caddr_t)disk_p[i],
X		(void*)&disk,sizeof(struct disk)) )
X	    {
X		fputs( "Could not read disk record.\n", stdout );
X		return 0;
X	    }
X	    if( !memRead(globalProfile.p_fdMem,(caddr_t)disk.dk_stat,
X		(void*)&stat,sizeof(struct met_disk_stats)) )
X	    {
X		fputs( "Could not read met_disk_stats_t record.\n", stdout );
X		return 0;
X	    }
X
X#if 0
X	    fprintf( stdout, "Disk %d, \"%s\".\n", i, stat.ds_name );
X	    fprintf( stdout, "\tQueue length %u.\n", stat.ds_qlen );
X	    fprintf( stdout, "\tReads, writes %lu %lu.\n",
X		stat.ds_op[MET_DS_READ],
X		stat.ds_op[MET_DS_WRITE] );
X	    fprintf( stdout, "Block reads, writes %lu %lu.\n",
X		stat.ds_opblks[MET_DS_READ],
X		stat.ds_opblks[MET_DS_WRITE] );
X	    fflush( stdout );
X#endif
X
X	    strcpy( sargDisk.disks[i-1].name, stat.ds_name );
X	    sargDisk.disks[i-1].qlen = stat.ds_qlen;
X	    sargDisk.disks[i-1].resp = stat.ds_resp;
X	    sargDisk.disks[i-1].active = stat.ds_active;
X	    sargDisk.disks[i-1].cntRW =
X		stat.ds_op[MET_DS_READ] + stat.ds_op[MET_DS_WRITE];
X	    sargDisk.disks[i-1].cntBRW =
X		stat.ds_opblks[MET_DS_READ] + stat.ds_opblks[MET_DS_WRITE];
X	}
X    }
X
X    /*
X    ** General metrics facility data.
X    */
X    {
X	int i;
X	struct metp_buf *ptr;
X
X	if( (ptr=(struct metp_buf*)metFetch(SARG_VAR_BUF)) != NULL )
X	{
X	    for( i=0; i<globalProfile.p_cntEngines; ++i )
X	    {
X		sargDisk.cntReadBuf = ptr->mpb_bread;
X		sargDisk.cntWriteBuf = ptr->mpb_bwrite;
X		sargDisk.cntReadLogic = ptr->mpb_lread;
X		sargDisk.cntWriteLogic = ptr->mpb_lwrite;
X		sargDisk.cntReadPhys = ptr->mpb_phread;
X		sargDisk.cntWritePhys = ptr->mpb_phwrite;
X		ptr += sizeof(struct metp_buf);
X	    }
X	}
X	else
X	{
X	    fputs( "Could not read disk metrics.\n", stdout );
X	}
X    }
X#endif
X
X    return diskWrite((void*)&sargDisk,sizeof(sargDisk),SARG_RTYP_DISK);
X}
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/disk.c' ||
  $echo 'restore of' 'orion-1.0/sargent/disk.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/disk.c:' 'MD5 check failed'
43e15b4a56826abf03316017e385967f  orion-1.0/sargent/disk.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/disk.c'`"
    test 6496 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/disk.c:' 'original size' '6496,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/tty.c ==============
if test -f 'orion-1.0/sargent/tty.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/tty.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/tty.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/tty.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#include"sarg_p.h"
X
X/*
X** ttySample()
X**
X*/
Xint ttySample( int fdMem )
X{
X    int i;
X    struct sargTty sargTty;
X
X    if( globalProfile.p_debug )
X	fputs( "Making TTY sample.\n", stdout );
X
X#if defined(ORION_FEAT_SYSINFO)
X    {
X	struct sysinfo *si;
X
X	si = siFetch( SARG_VAR_SYSINFO );
X
X	sargTty.cntTtyRaw = si->rawch;
X	sargTty.cntTtyCan = si->canch;
X	sargTty.cntTtyOut = si->outch;
X	sargTty.cntIntrRcv = si->rcvint;
X	sargTty.cntIntrXmt = si->xmtint;
X	sargTty.cntIntrMdm = si->mdmint;
X    }
X#endif
X
X#if defined(ORION_FEAT_METRICS)
X    {
X	int i;
X	struct metp_tty *ptr;
X
X	sargTty.cntTtyRaw = 0;
X	sargTty.cntTtyCan = 0;
X	sargTty.cntTtyOut = 0;
X	sargTty.cntIntrRcv = 0;
X	sargTty.cntIntrXmt = 0;
X	sargTty.cntIntrMdm = 0;
X
X	if( (ptr=(struct metp_tty*)metFetch(SARG_VAR_TTY)) != NULL )
X	{
X	    for( i=0; i<globalProfile.p_cntEngines; ++i )
X	    {
X		sargTty.cntTtyRaw += ptr->mpt_rawch;
X		sargTty.cntTtyCan += ptr->mpt_canch;
X		sargTty.cntTtyOut += ptr->mpt_outch;
X		sargTty.cntIntrRcv += ptr->mpt_rcvint;
X		sargTty.cntIntrXmt += ptr->mpt_xmtint;
X		sargTty.cntIntrMdm += ptr->mpt_mdmint;
X		ptr += sizeof(struct metp_tty);
X	    }
X	}
X	else
X	{
X	    fputs( "Could not read TTY metrics.\n", stdout );
X	}
X    }
X#endif
X
X    return diskWrite((void*)&sargTty,sizeof(sargTty),SARG_RTYP_TTY);
X}
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/tty.c' ||
  $echo 'restore of' 'orion-1.0/sargent/tty.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/tty.c:' 'MD5 check failed'
3a5931b6c3f10662e88be80c43fbf198  orion-1.0/sargent/tty.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/tty.c'`"
    test 1907 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/tty.c:' 'original size' '1907,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/streams.c ==============
if test -f 'orion-1.0/sargent/streams.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/streams.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/streams.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/streams.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#include"sarg_p.h"
X
X#if defined(VENIX32) || defined(SVR3)
Xstatic int maxDblock = -1;
Xstatic int maxNmblock = -1;
X#endif
X
Xint streamsInit( int fd )
X{
X#if defined(VENIX32) || defined(SVR3)
X    maxDblock = 0;
X    maxDblock += globalProfile.kern_var.v_nblk4096;
X    maxDblock += globalProfile.kern_var.v_nblk2048;
X    maxDblock += globalProfile.kern_var.v_nblk1024;
X    maxDblock += globalProfile.kern_var.v_nblk512;
X    maxDblock += globalProfile.kern_var.v_nblk256;
X    maxDblock += globalProfile.kern_var.v_nblk128;
X    maxDblock += globalProfile.kern_var.v_nblk64;
X    maxDblock += globalProfile.kern_var.v_nblk16;
X    maxDblock += globalProfile.kern_var.v_nblk4;
X
X    if( !memFetch(SARG_VAR_NMBLOCK,(void*)&maxNmblock,sizeof(maxNmblock)) )
X    {
X	maxNmblock = -1;
X	fputs( "Could not fetch \"nmblock\".\n", stdout );
X	return 0;
X    }
X#endif
X}
X
X/*
X** streamsSample()
X**
X*/
Xint streamsSample( int fdMem )
X{
X    int i;
X    struct sargStreams sargStreams;
X
X    if( globalProfile.p_debug )
X	fputs( "Making STREAMS sample.\n", stdout );
X
X    /*
X    ** Find out how many queues are in use. Read in the entire
X    ** queue table and count the number of referenced entries.
X    */
X#if defined(SVR3) || defined(VENIX32)
X    {
X	unsigned count;
X	struct queue *recQueue;
X	mblk_t *recMblock;
X	dblk_t *recDblock;
X
X	if( !memFetch(SARG_VAR_QUEUE,globalProfile.p_scratch,
X	    sizeof(struct queue)*globalProfile.kern_var.v_nqueue) )
X	{
X	    fputs( "Could not fetch \"queue\".\n", stdout );
X	    return 0;
X	}
X	count = 0;
X	for( recQueue=(struct queue*)globalProfile.p_scratch,i=0;
X	    i<globalProfile.kern_var.v_nqueue; ++i,++recQueue )
X	{
X	    if( recQueue->q_qinfo != NULL )
X		++count;
X	}
X	sargStreams.perQueues = (count*100) /
X	    globalProfile.kern_var.v_nqueue;
X
X	/*
X	** Find out how many message blocks are in use. Read in the entire
X	** table and count the number of referenced entries.
X	*/
X
X	if( !memFetch(SARG_VAR_MBLOCK,globalProfile.p_scratch,
X	    sizeof(mblk_t)*maxNmblock) )
X	{
X	    fputs( "Could not fetch \"mblock\".\n", stdout );
X	    return 0;
X	}
X
X	count = 0;
X	for( recMblock=(mblk_t*)globalProfile.p_scratch,i=0;
X	    i<maxNmblock; ++i,++recMblock )
X	{
X	    if( recMblock->b_datap != NULL )
X		++count;
X	}
X	sargStreams.perMsgblks = (count*100) / maxNmblock;
X
X	/*
X	** Find out how many data blocks are in use. Read in the entire
X	** table and count the number of referenced entries.
X	*/
X
X	if( !memFetch(SARG_VAR_DBLOCK,globalProfile.p_scratch,
X	    sizeof(dblk_t)*maxDblock) )
X	{
X	    fputs( "Could not fetch \"dblock\".\n", stdout );
X	    return 0;
X	}
X
X	count = 0;
X	for( recDblock=(dblk_t*)globalProfile.p_scratch,i=0;
X	    i<maxDblock; ++i,++recDblock )
X	{
X	    if( recDblock->db_ref > 0 )
X		++count;
X	}
X	sargStreams.perDatablks= (count*100) / maxDblock;
X    }
X#endif
X
X    /*
X    ** Aggregate STREAMS metrics.
X    **
X    ** Percentages are percentage of current allocation. There are no
X    ** maximums when it comes to STREAMS resources.
X    */
X#if defined(ORION_FEAT_METRICS)
X    {
X	int i;
X	long maxQ, maxMsg, maxDbl;
X	long useQ, useMsg, useDbl;
X	struct metp_str_resrc *ptr;
X
X	sargStreams.perQueues   = 0.0;
X	sargStreams.perMsgblks  = 0.0;
X	sargStreams.perDatablks = 0.0;
X	if( (ptr=(struct metp_str_resrc*)metFetch(SARG_VAR_STR)) != NULL )
X	{
X	    maxQ = maxMsg = maxDbl = 0;
X	    useQ = useMsg = useDbl = 0;
X	    for( i=0; i<globalProfile.p_cntEngines; ++i )
X	    {
X		maxQ   += ptr->str_stream[MET_CURRENT];
X		maxMsg += ptr->str_msgblock[MET_CURRENT];
X		maxDbl += ptr->str_mdbblock[MET_CURRENT];
X		useQ   += ptr->str_stream[MET_INUSE];
X		useMsg += ptr->str_msgblock[MET_INUSE];
X		useDbl += ptr->str_mdbblock[MET_INUSE];
X		ptr += sizeof(struct metp_str_resrc);
X	    }
X	    if( maxQ > 0 )
X		sargStreams.perQueues = (useQ*100)   / maxQ;
X	    if( maxMsg > 0 )
X		sargStreams.perMsgblks  = (useMsg*100) / maxMsg;
X	    if( maxDbl > 0 )
X		sargStreams.perDatablks = (useDbl*100) / maxDbl;
X	}
X    }
X#endif
X
X#if defined(SCO5)
X    {
X	struct strstat *stat;
X
X	if( !memFetch(SARG_VAR_STRSTAT,globalProfile.p_scratch,
X	    sizeof(struct strstat)) )
X	{
X		fputs( "Could not fetch \"strstat\".\n", stdout );
X	    return 0;
X	}
X	stat = (struct strstat*)globalProfile.p_scratch;
X
X	if( stat->queue.max > 0 )
X	{
X	    sargStreams.perQueues = (float)(stat->queue.use*100) /
X		stat->queue.max;
X	}
X	else
X	    sargStreams.perQueues = 0.0;
X
X	if( stat->mblock.max > 0 )
X	{
X	    sargStreams.perMsgblks  = (float)(stat->mblock.use*100) /
X		stat->mblock.max;
X	}
X	else
X	    sargStreams.perMsgblks = 0.0;
X
X	/*
X	** Doesn't seem to work (always zero).
X	**
X	** if( stat->dblock.max > 0 )
X	** {
X	**     sargStreams.perDatablks = (float)(stat->dblock.use*100) /
X	** 	stat->dblock.max;
X	** }
X	** else
X	**     sargStreams.perDatablks = 0.0;
X	*/
X	{
X	    int i;
X	    int use = 0;
X	    int max = 0;
X
X	    for( i=0; i<NCLASS; ++i )
X	    {
X		use += stat->dblk[i].use;
X		max += stat->dblk[i].max;
X	    }
X	    sargStreams.perDatablks = (float)(use*100)/(float)max;
X	}
X    }
X#endif
X
X    return diskWrite((void*)&sargStreams,sizeof(sargStreams),
X	SARG_RTYP_STREAMS);
X}
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/streams.c' ||
  $echo 'restore of' 'orion-1.0/sargent/streams.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/streams.c:' 'MD5 check failed'
9e6d2a078903b822bda6c634141621c5  orion-1.0/sargent/streams.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/streams.c'`"
    test 5656 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/streams.c:' 'original size' '5656,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/venix.c ==============
if test -f 'orion-1.0/sargent/venix.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/venix.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/venix.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/venix.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#ifdef VENIX32
X
X/*
X** The local header files are placed first, because they contain
X** many references to kernel headers.
X*/
X#include"lsar.h"
X#include"collie.h"
X
X/*
X** VENIX record type.
X**
X** Tracks data specific to VENIX 3.2.
X*/
X
X/*
X** VenturCom bug fix. 11/1995. Counts number of times that
X** region list pointer was corrupted and fixed.
X*/
Xstatic const char * const S_SymFix = "reglist_fix_cnt";
X
Xstatic caddr_t addrFix = 0;
X
Xint venixInit( int fd )
X{
X    struct nlist recNlists[2];
X
X    recNlists[0].n_name = (char*)S_SymFix;
X    recNlists[0].n_value = 0;
X    recNlists[1].n_name = (char*)S_Empty;
X    if( nlist(S_PathKern,recNlists) == -1 )
X    {
X	fputs( "Bad nlist() on VENIX symbols.\n", stdout );
X	return 0;
X    }
X
X    addrFix = (caddr_t)recNlists[0].n_value;
X
X    if( globalProfile.p_debug )
X    {
X	if( addrFix != (caddr_t)0 )
X	    fputs( "Detected VENIX vhand special fix.\n", stdout );
X    }
X
X    return 1;
X}
X
Xint venixSample( int fd )
X{
X    int i;
X    struct lsarVenix lsarVenix;
X
X    if( addrFix == (caddr_t)0 )
X	return 1;
X
X    if( globalProfile.p_debug )
X	fputs( "Making VENIX sample.\n", stdout );
X
X    if( !memRead(fd,addrFix,(caddr_t)&lsarVenix.cntVhand,
X	sizeof(lsarVenix.cntVhand)) )
X    {
X	fprintf( stdout, "Could not read \"%s\".\n", S_SymFix );
X	return 0;
X    }
X
X    if( globalProfile.p_findings )
X	fprintf( stdout, "vhand fix: %d.\n", lsarVenix.cntVhand );
X
X    return diskWrite((void*)&lsarVenix,sizeof(lsarVenix),
X	LSAR_RTYP_VENIX);
X}
X
X#endif
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/venix.c' ||
  $echo 'restore of' 'orion-1.0/sargent/venix.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/venix.c:' 'MD5 check failed'
12ac13037d88895a3e4b61f519dcfc23  orion-1.0/sargent/venix.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/venix.c'`"
    test 2104 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/venix.c:' 'original size' '2104,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/wollong.c ==============
if test -f 'orion-1.0/sargent/wollong.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/wollong.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/wollong.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/wollong.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#ifdef WOLLONG32
X
X/*
X** The local header files are placed first, because they contain
X** many references to kernel headers.
X*/
X#include"collie.h"
X#include<sys/etstream.h>
X
X/*
X** Wollongong record type.
X**
X** Tracks data specific to Wollongong SVR3 network drivers.
X*/
X
Xstatic const char * const S_SymEplus = "eplusstrms";
Xstatic const char * const S_SymEc503 = "ec503strms";
Xstatic const char * const S_SymEc501 = "ec501strms";
Xstatic const char * const S_SymLe16d = "le16dstrms";
X
Xstatic caddr_t addrWollong[4];
X
Xint wollongInit( int fd )
X{
X    struct nlist recNlists[5];
X
X    recNlists[0].n_name = (char*)S_SymEplus;
X    recNlists[0].n_value = 0;
X    recNlists[1].n_name = (char*)S_SymEc503;
X    recNlists[1].n_value = 0;
X    recNlists[2].n_name = (char*)S_SymEc501;
X    recNlists[2].n_value = 0;
X    recNlists[3].n_name = (char*)S_SymLe16d;
X    recNlists[3].n_value = 0;
X    recNlists[4].n_name = (char*)S_Empty;
X    if( nlist(S_PathKern,recNlists) == -1 )
X    {
X	fputs( "Bad nlist() on Wollongong symbols.\n", stdout );
X	return 0;
X    }
X
X    addrWollong[LSAR_WOLLONG_EPLUS] =
X	(caddr_t)recNlists[LSAR_WOLLONG_EPLUS].n_value;
X    addrWollong[LSAR_WOLLONG_EC503] =
X	(caddr_t)recNlists[LSAR_WOLLONG_EC503].n_value;
X    addrWollong[LSAR_WOLLONG_EC501] =
X	(caddr_t)recNlists[LSAR_WOLLONG_EC501].n_value;
X    addrWollong[LSAR_WOLLONG_LE16D] =
X	(caddr_t)recNlists[LSAR_WOLLONG_LE16D].n_value;
X
X    if( globalProfile.p_debug )
X    {
X	if( addrWollong[LSAR_WOLLONG_EPLUS] )
X	    fputs( "Detected a Wollongong WD8003 SVR3 driver.\n", stdout );
X	if( addrWollong[LSAR_WOLLONG_EC503] )
X	    fputs( "Detected a Wollongong EC503 SVR3 driver.\n", stdout );
X	if( addrWollong[LSAR_WOLLONG_EC501] )
X	    fputs( "Detected a Wollongong EC501 SVR3 driver.\n", stdout );
X	if( addrWollong[LSAR_WOLLONG_LE16D] )
X	    fputs( "Detected a Wollongong LE16D SVR3 driver.\n", stdout );
X    }
X
X    return 1;
X}
X
Xint wollongSample( int fd )
X{
X    int i, countEtstrm;
X    struct etdev  recDev;
X    struct etstrm etstrm;
X    struct etstrm etstrms[8];
X    struct lsarWollong lsarWollong;
X
X    if( globalProfile.p_debug )
X	fputs( "Making Wollongong sample.\n", stdout );
X
X    lsarWollong.valid = 0;
X
X    for( i=0; i<LSAR_MAX_WOLLONG; ++i )
X    {
X	if( addrWollong[i] == (caddr_t)0 )
X	    continue;
X
X	lsarWollong.valid |= (1<<i);
X	if( !memRead(fd,addrWollong[i],(caddr_t)&etstrms,
X	    sizeof(struct etstrm)*8) )
X	{
X	    fputs( "Could not read a Wollongong SVR3 variable.\n", stdout );
X	    continue;
X	}
X
X	lsarWollong.devs[i].cntTxHard = 0;
X	lsarWollong.devs[i].cntTxDiscard = 0;
X	lsarWollong.devs[i].cntTxUnder = 0;
X	lsarWollong.devs[i].cntRxHard = 0;
X	lsarWollong.devs[i].cntRxDiscard = 0;
X	lsarWollong.devs[i].cntRxOver = 0;
X
X	countEtstrm = 0;
X	for( i=0; i<8; ++i )
X	{
X	    if( etstrm.et_hdwr == NULL )
X		continue;
X	    ++countEtstrm;
X
X	    if( !memRead(fd,(caddr_t)(etstrms[i].et_hdwr),
X		(caddr_t)&recDev,sizeof(struct etdev)) )
X	    {
X		fputs( "Could not read in a \"struct etdev\".\n", stdout );
X		return 0;
X	    }
X	    lsarWollong.devs[i].cntTxHard += recDev.etd_stats.ntx_hdwr_error;
X	    lsarWollong.devs[i].cntTxDiscard += recDev.etd_stats.ntx_discard;
X	    lsarWollong.devs[i].cntTxUnder += recDev.etd_stats.ntx_fifounder;
X	    lsarWollong.devs[i].cntRxHard += recDev.etd_stats.ntr_hdwr_error;
X	    lsarWollong.devs[i].cntRxDiscard += recDev.etd_stats.ntr_discard;
X	    lsarWollong.devs[i].cntRxOver += recDev.etd_stats.ntr_fifoover;
X	    lsarWollong.devs[i].cntRxCrc += recDev.etd_stats.ntr_crc;
X	}
X    }
X    if( globalProfile.p_findings )
X	fprintf( stdout, "%d etstrms.\n", countEtstrm );
X
X    return diskWrite((void*)&lsarWollong,sizeof(lsarWollong),
X	LSAR_RTYP_WOLLONG);
X}
X
X#endif
SHAR_EOF
  chmod 0664 'orion-1.0/sargent/wollong.c' ||
  $echo 'restore of' 'orion-1.0/sargent/wollong.c' 'failed'
  if ( md5sum --help 2>&1 | grep 'sage: md5sum \[' ) >/dev/null 2>&1 \
  && ( md5sum --version 2>&1 | grep -v 'textutils 1.12' ) >/dev/null; then
    md5sum -c << SHAR_EOF >/dev/null 2>&1 \
    || $echo 'orion-1.0/sargent/wollong.c:' 'MD5 check failed'
0da9f2fbbf4564124c70fe7b2e97f529  orion-1.0/sargent/wollong.c
SHAR_EOF
  else
    shar_count="`LC_ALL= LC_CTYPE= LANG= wc -c < 'orion-1.0/sargent/wollong.c'`"
    test 4294 -eq "$shar_count" ||
    $echo 'orion-1.0/sargent/wollong.c:' 'original size' '4294,' 'current size' "$shar_count!"
  fi
fi
# ============= orion-1.0/sargent/memsys.c ==============
if test -f 'orion-1.0/sargent/memsys.c' && test "$first_param" != -c; then
  $echo 'x -' SKIPPING 'orion-1.0/sargent/memsys.c' '(file already exists)'
  rm -f _sh05649/new
else
  > _sh05649/new
  $echo 'x -' extracting 'orion-1.0/sargent/memsys.c' '(text)'
  sed 's/^X//' << 'SHAR_EOF' > 'orion-1.0/sargent/memsys.c' &&
X
X/*
X** ----------------------------------------------------------------
X**
X**  Copyright (c) 1994,1995,1996 by Larry Plona
X**
X**  This file is part of the Orion software package. The Orion
X**  software package is copyright by its author, Larry Plona. This
X**  software, both source code and prepared binaries, may be
X**  freely distributed as long as all copyright notices remain
X**  intact and this software is not sold or packaged with other
X**  commercial software.
X**
X**  No warranty of any kind attached with this software. It is
X**  supplied as is.
X**
X** ----------------------------------------------------------------
X*/
X
X#include"sarg_p.h"
X
X/*
X** memsysSample()
X**
X*/
Xint memsysSample( int fdMem )
X{
X    int i;
X    struct sargMemsys rec;
X    struct mets *m;
X    struct minfo *mi;
X
X    if( globalProfile.p_debug )
X	fputs( "Making Memsys sample.\n", stdout );
X
X#if defined(ORION_FEAT_SYSINFO)
X    memRead( fdMem, memAddr(SARG_VAR_FREEMEM),
X	(void*)&rec.cntMemRam, sizeof(dl_t) );
X
X    mi = siFetch( SARG_VAR_MINFO );
X    rec.cntMemSwap.dl_lop = mi->freeswap;
X
X    rec.perUsed = -1;
X    rec.cntFail = 0;
X    rec.cntSucced = 0;
X#endif
X
X#if defined(ORION_FEAT_METRICS)
X    if( !memFetch(SARG_VAR_METS,(void*)&globalProfile.kern_mets,
X	sizeof(struct mets)) )
X    {
X	fprintf( stdout, "Could not fetch \"mets\". %s.\n",
X	    sys_errlist[errno] );
X	return 0;
X    }
X
X    m = &globalProfile.kern_mets;
SHAR_EOF
  : || $echo 'restore of' 'orion-1.0/sargent/memsys.c' 'failed'
fi
$echo 'End of' 'orion-1.0' 'part' '7'
$echo 'File' 'orion-1.0/sargent/memsys.c' 'is continued in part' '8'
echo 8 > _sh05649/seq
exit 0