v10i060: SPS for BSD, Ultrix1.2, Sun3.x, NFS, Part01/03

Showing 1-1 of 1 messages
v10i060: SPS for BSD, Ultrix1.2, Sun3.x, NFS, Part01/03 Rich Salz 7/22/87 5:17 PM
Submitted-by: robert@hslrswi.UUCP (Robert Ward)
Posting-Number: Volume 10, Issue 60
Archive-name: sps/Part01

[  This is a fast, public, version of "ps" for BSD-derived Unices..  --r$  ]

Hello Net,

This is another posting of SPS, hopefully the last for quite a while now.
This version is the same as the one last posted to comp.sources.unix
except that it includes fixes for those 4.3 systems with NFS. These
additions were incorporated by Alexander Dupuy <du...@amsterdam.columbia.edu>
who writes:

> Sun-specific changes
>
>         A minor bugfix to "getcmd.c" to deal with processes which have no stack
> (this is the case for nfs async block i/o daemons on some VMEbus Suns).
>
>
> 4.3+NFS changes
>
>         Changes to conditionalization to support NFS on non-Sun systems.
> Several things like disc quotas are reimplemented with NFS, and should be
> ignored on any NFS system, not just Suns.  The files "globals2.c" and
> "waitingfor.c" were changed to support non-Sun NFS systems.  The file
> "Makefile.sun" was changed to add the -DNFS option, and a new Makefile for
> 4.3+NFS systems was added.
>
>                                         Alexander Dupuy

As usual, please mail all comments and fixes to myself (Robert) at:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    J. Robert Ward,                                                   ___________
    Hasler AG, Belpstrasse 23, CH-3000 Berne 14, Switzerland           |    _    |
                                                                   |  _| |_  |
Tel.:            +41 31 632319                                           | |_   _| |
X.400:            robert@hslrswi.hasler                                   |   |_|   |
Bitnet:            robert%hslrswi.UUCP@cernvax.BITNET                              |_________|
Uucp:            ... {seismo,ukc, ... }!mcvax!cernvax!hslrswi!robert
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#                "End of archive 1 (of 3)."
# Contents:  MANIFEST Makefile.4.1 Makefile.4.2 Makefile.4.3
#   Makefile.4.3+NFS Makefile.sun README README2 filecount.c findtty.c
#   flags.h flagsetup.c getupage.c globals1.c hashuid.c initialise.c
#   initsymbols.c main.c mktree.c openfiles.c percentmem.c prcmd.c
#   prcpu.c prheader.c printall.c prsummary.c readstatus.c
#   selectproc.c selecttty.c termwidth.c ttystatus.c
# Wrapped by rs@uunet on Wed Jul 22 20:09:05 1987
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f MANIFEST -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"MANIFEST\"
else
echo shar: Extracting \"MANIFEST\" \(1344 characters\)
sed "s/^X//" >MANIFEST <<'END_OF_MANIFEST'
X   File Name                Archive #        Description
X-----------------------------------------------------------
X MANIFEST                  1        This shipping list
X Makefile.4.1              1        
X Makefile.4.2              1        
X Makefile.4.3              1        
X Makefile.4.3+NFS          1        
X Makefile.sun              1        
X README                    1        
X README2                   1        
X filecount.c               1        
X findtty.c                 1        
X flagdecode.c              2        
X flags.h                   1        
X flagsetup.c               1        
X getcmd.c                  2        
X getupage.c                1        
X globals1.c                1        
X globals2.c                2        
X hashuid.c                 1        
X initialise.c              1        
X initsymbols.c             1        
X inittty.c                 2        
X main.c                    1        
X mktree.c                  1        
X needed.c                  2        
X openfiles.c               1        
X patches                   3        
X percentmem.c              1        
X prcmd.c                   1        
X prcpu.c                   1        
X prheader.c                1        
X printall.c                1        
X printproc.c               2        
X prsummary.c               1        
X readstatus.c              1        
X selectproc.c              1        
X selecttty.c               1        
X sps.h                     2        
X sps.man                   3        
X termwidth.c               1        
X ttystatus.c               1        
X waitingfor.c              2        
END_OF_MANIFEST
if test 1344 -ne `wc -c <MANIFEST`; then
    echo shar: \"MANIFEST\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.4.1 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.4.1\"
else
echo shar: Extracting \"Makefile.4.1\" \(882 characters\)
sed "s/^X//" >Makefile.4.1 <<'END_OF_Makefile.4.1'
X# Makefile for SPS (4.1BSD UNIX Version)
X
XPROG    =       sps
XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
X                getcmd.o getupage.o globals1.o globals2.o hashuid.o \
X                initialise.o initsymbols.o inittty.o main.o mktree.o \
X                needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
X                prheader.o printall.o printproc.o prsummary.o readstatus.o \
X                selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
X
XINCS    =       sps.h
XLIBS    =       -ltermlib
XCFLAGS  =       -I/usr/src/sys -DCHAOS
X
Xall:            $(PROG)
X.c.o:
X                cc $(CFLAGS) -c -O -R $<
Xglobals1.o waitingfor.o:
X                cc $(CFLAGS) -c -O $<
X
X$(OBJS):        $(INCS)
X
X$(PROG):        $(OBJS)
X                cc -o $@ $(OBJS) $(LIBS)
X
Xinstall:        $(PROG)
X                strip $(PROG)
X                mv $(PROG) /bin/$(PROG)
X                /etc/chown root /bin/$(PROG)
X                chmod 4711 /bin/$(PROG)
X
Xlint:
X                lint -x -b $(CFLAGS) *.c
Xclean:
X                rm -f $(OBJS) $(PROG)
END_OF_Makefile.4.1
if test 882 -ne `wc -c <Makefile.4.1`; then
    echo shar: \"Makefile.4.1\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.4.2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.4.2\"
else
echo shar: Extracting \"Makefile.4.2\" \(977 characters\)
sed "s/^X//" >Makefile.4.2 <<'END_OF_Makefile.4.2'
X# Makefile for SPS (Vax 4.2BSD and Ultrix1.2 UNIX Version)
X
XPROG    =       sps
XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
X                getcmd.o getupage.o globals1.o globals2.o hashuid.o \
X                initialise.o initsymbols.o inittty.o main.o mktree.o \
X                needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
X                prheader.o printall.o printproc.o prsummary.o readstatus.o \
X                selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
XINCS    =       sps.h
XCC      =       cc
XCFLAGS  =       -DBSD42 -I/sys
XLIBS    =       -ltermlib
XDIRINSTALL =        /bin
X
Xall:                    $(PROG)
X.c.o:
X                $(CC) $(CFLAGS) -c -O -R $<
X        
Xglobals1.o waitingfor.o:
X                $(CC) $(CFLAGS) -c -O $<
X
X$(OBJS):                $(INCS)
X
X$(PROG):                $(OBJS)
X                $(CC) -o $@ $(OBJS) $(LIBS)
X
Xinstall:                $(PROG)
X                strip $(PROG)
X                mv $(PROG) $(DIRINSTALL)/$(PROG)
X                /etc/chown root $(DIRINSTALL)/$(PROG)
X                chgrp kmem $(DIRINSTALL)/$(PROG)
X                chmod 2755 $(DIRINSTALL)/$(PROG)
X
Xlint:
X                lint -x -b $(CFLAGS) *.c
Xclean:
X                rm -f $(OBJS) $(PROG)
END_OF_Makefile.4.2
if test 977 -ne `wc -c <Makefile.4.2`; then
    echo shar: \"Makefile.4.2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.4.3 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.4.3\"
else
echo shar: Extracting \"Makefile.4.3\" \(966 characters\)
sed "s/^X//" >Makefile.4.3 <<'END_OF_Makefile.4.3'
X# Makefile for SPS (Vax 4.3BSD Version)
X
XPROG    =       sps
XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
X                getcmd.o getupage.o globals1.o globals2.o hashuid.o \
X                initialise.o initsymbols.o inittty.o main.o mktree.o \
X                needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
X                prheader.o printall.o printproc.o prsummary.o readstatus.o \
X                selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
XINCS    =       sps.h
XCC      =       cc
XCFLAGS  =       -DBSD42 -DBSD43 -I/sys
XLIBS    =       -ltermlib
XDIRINSTALL =        /bin
X
Xall:                    $(PROG)
X.c.o:
X                $(CC) $(CFLAGS) -c -O -R $<
X        
Xglobals1.o waitingfor.o:
X                $(CC) $(CFLAGS) -c -O $<
X
X$(OBJS):                $(INCS)
X
X$(PROG):                $(OBJS)
X                $(CC) -o $@ $(OBJS) $(LIBS)
X
Xinstall:                $(PROG)
X                strip $(PROG)
X                mv $(PROG) $(DIRINSTALL)/$(PROG)
X                /etc/chown root $(DIRINSTALL)/$(PROG)
X                chgrp kmem $(DIRINSTALL)/$(PROG)
X                chmod 2755 $(DIRINSTALL)/$(PROG)
X
Xlint:
X                lint -x -b $(CFLAGS) *.c
Xclean:
X                rm -f $(OBJS) $(PROG)
END_OF_Makefile.4.3
if test 966 -ne `wc -c <Makefile.4.3`; then
    echo shar: \"Makefile.4.3\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.4.3+NFS -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.4.3+NFS\"
else
echo shar: Extracting \"Makefile.4.3+NFS\" \(1089 characters\)
sed "s/^X//" >Makefile.4.3+NFS <<'END_OF_Makefile.4.3+NFS'
X# Makefile for SPS (Vax 4.3BSD Version)
XPROG    =       sps
XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
X        initialise.o initsymbols.o inittty.o main.o mktree.o \
X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
XINCS    =       sps.h
XCC      =       cc
XCFLAGS  =       -DBSD42 -DBSD43 -DQUOTA -DNFS -I/sys
XLIBS    =       -ltermlib
XDIRINSTALL =    /bin
Xall:            $(PROG)
X.c.o:
X        $(CC) $(CFLAGS) -c -O -R $<
Xglobals1.o waitingfor.o:
X        $(CC) $(CFLAGS) -c -O $<
X$(OBJS):        $(INCS)
X$(PROG):        $(OBJS)
X        $(CC) -o $@ $(OBJS) $(LIBS)
Xinstall:        $(PROG)
X        strip $(PROG)
X        mv $(PROG) $(DIRINSTALL)/$(PROG)
X        /etc/chown root $(DIRINSTALL)/$(PROG)
X        chgrp kmem $(DIRINSTALL)/$(PROG)
X        chmod 2755 $(DIRINSTALL)/$(PROG)
Xlint:
X        lint -x -b $(CFLAGS) *.c
Xclean:
X        rm -f $(OBJS) $(PROG)
END_OF_Makefile.4.3+NFS
if test 1089 -ne `wc -c <Makefile.4.3+NFS`; then
    echo shar: \"Makefile.4.3+NFS\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f Makefile.sun -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"Makefile.sun\"
else
echo shar: Extracting \"Makefile.sun\" \(988 characters\)
sed "s/^X//" >Makefile.sun <<'END_OF_Makefile.sun'
X# Makefile for SPS (Sun-2 and Sun-3, 4.2BSD UNIX Version)
X
XPROG    =       sps
XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
X                getcmd.o getupage.o globals1.o globals2.o hashuid.o \
X                initialise.o initsymbols.o inittty.o main.o mktree.o \
X                needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
X                prheader.o printall.o printproc.o prsummary.o readstatus.o \
X                selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
XINCS    =       sps.h
XCC      =       cc
XCFLAGS  =       -DSUN -DBSD42 -DNFS -I/sys
XLIBS    =       -ltermlib
XDIRINSTALL        = /bin
X
Xall:                    $(PROG)
X.c.o:
X                $(CC) $(CFLAGS) -c -O -R $<
X        
Xglobals1.o waitingfor.o:
X                $(CC) $(CFLAGS) -c -O $<
X
X$(OBJS):                $(INCS)
X
X$(PROG):                $(OBJS)
X                $(CC) -o $@ $(OBJS) $(LIBS)
X
Xinstall:                $(PROG)
X                strip $(PROG)
X                mv $(PROG) $(DIRINSTALL)/$(PROG)
X                /etc/chown root $(DIRINSTALL)/$(PROG)
X                chgrp kmem $(DIRINSTALL)/$(PROG)
X                chmod 2755 $(DIRINSTALL)/$(PROG)
X
Xlint:
X                lint -x -b $(CFLAGS) *.c
Xclean:
X                rm -f $(OBJS) $(PROG)
END_OF_Makefile.sun
if test 988 -ne `wc -c <Makefile.sun`; then
    echo shar: \"Makefile.sun\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f README -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"README\"
else
echo shar: Extracting \"README\" \(1226 characters\)
sed "s/^X//" >README <<'END_OF_README'
X                SPS - Show Process Status
X                =========================
XTo compile, install and test, type the following commands (as super-user):
X        % make                  # Compile SPS
X        % make install          # Install SPS into /bin/sps
X        % sps i                 # Initialise SPS
X        % sps va                # Run SPS
X********************************************************************************
XThe files in this directory are for the 4.[12]BSD / VAX-11 version of SPS.
XCompiler options are as follows -
X        -DCHAOS         if the Chaos network is incorporated into 4.xbsd
X        -DTRACE         for testing/debugging purposes
X        -DBSD42         compile SPS for 4.2bsd.
X                        Otherwise, SPS is compiled for 4.1bsd.
X********************************************************************************
XIf you want to tell SPS about a new type of device, then add a new line to
Xthe symbol table (see globals2.c),after ensuring that there is sufficient
Xroom in the `info' structure. (NWAITSTATE may need to be increased in sps.h).
X********************************************************************************
XSPS understands if the size of internal kernel tables are changed under VMUNIX,
Xbut must be recompiled if major modifications are made to the kernel.
END_OF_README
if test 1226 -ne `wc -c <README`; then
    echo shar: \"README\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f README2 -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"README2\"
else
echo shar: Extracting \"README2\" \(3050 characters\)
sed "s/^X//" >README2 <<'END_OF_README2'
X                SPS  -  Show Process Status
X                ===========================
X
XSPS is a intended to be used as a replacement for the standard ps(1)
Xprogram. Its advantages over ps(1) are that it shows more useful
Xinformation and that it is faster.
X
XSPS is currently implemented for 4.1 and 4.2bsd Unix on Vaxen and for
XSun's 4.2bsd/Release 2. (I also have a somewhat older implementation
Xfor V7 on a PDP-11 as well as Unisoft Version 1.3 on a MC68000 if you
Xare interested).
X
XSPS displays wait channels symbolically, rather than as hexadecimal
Xaddresses. If you wish to teach sps about a new sort of device, you
Xmust add an entry in the symbol table (globals2.c) as well as
Xincreasing the size of that table (NWAITSTATE in sps.h).
X
XSPS sorts processes before listing them. The order reflects the
Xrelationship of the processes. A child process is listed underneath its
Xcorresponding parent and is indented to depict the exact relationship.
XSPS also indicates setuid processes.
X
XSPS displays such values as the resident and virtual sizes of system
Xprocesses.  It accepts a whole range of options to control the output.
XBy default, SPS lists information about one's own processes. Other
Xoptions instruct it to be verbose (the "v" option), to list all the
Xcommand arguments of a process (the "w" option) or to list the
Xenvironment strings of that process (the "e" option). Similarly, there
Xare options to control which processes are to be displayed. The "a"
Xoption tells it to describe all processes and the "b" option tells it
Xto describe "busy" processes, which is useful if you wish to find out
Xwhat is loading your system. There are also options to select the
Xoutput according to user, controlling tty or process number.
X
XSPS keeps its information in an information file. By default, this is
X/etc/spsinfo. This means that it can avoid having to do an expensive
Xnlist() operation each time it is run. It must be reinitialised (with
Xthe "i" option) if new users are added to /etc/passwd or if a new
Xversion of /vmunix is installed.
X
XTo compile SPS, unbundle the four shell archive files.  Check that the
Xdefine statements in sps.h are large enough for your system (You may
Xneed to alter MAXTTYS).  Then compile it using the appropriate
XMakefile. Initialise it by typing "sps i" (ignore any error messages at
Xthis stage) and then test it out by typing "sps va". That should make
XSPS list verbose information about every process currently active. If
Xthat works, use the appropriate Makefile to install it.
X
XSend all bug reports, fixes, comments and suggestions to Robert Ward at -
X
X******************************************************************************
X    Robert Ward,
X    Hasler AG, Murtenstrasse 137a, CH-3008 Bern, Switzerland
X
XTel.:            (031) - 65 23 19
XUucp:            ... {seismo,decvax,ukc, ... }!mcvax!cernvax!hslrswi!robert
XBitnet:            hslrswi!robert@cernvax.bitnet
XArpa:            hslrswi!robert%cernvax.bitnet@WISCVM.ARPA
XEdunet:            hslrswi!robert%cernvax.bitnet@UCBJADE.Berkeley.EDU
X******************************************************************************
END_OF_README2
if test 3050 -ne `wc -c <README2`; then
    echo shar: \"README2\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f filecount.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"filecount.c\"
else
echo shar: Extracting \"filecount.c\" \(351 characters\)
sed "s/^X//" >filecount.c <<'END_OF_filecount.c'
X# include       "sps.h"
X
X/* FILECOUNT - Counts the # open files for the current process */
Xfilecount ()
X{
X        register int            i ;
X        register struct file    **f ;
X        register int            count ;
X        extern union userstate  User ;
X
X        count = 0 ;
X        for ( i = 0, f = User.u_us.u_ofile ; i < NOFILE ; i++ )
X                if ( *f++ )
X                        count++ ;
X        return ( count ) ;
X}
END_OF_filecount.c
if test 351 -ne `wc -c <filecount.c`; then
    echo shar: \"filecount.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f findtty.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"findtty.c\"
else
echo shar: Extracting \"findtty.c\" \(533 characters\)
sed "s/^X//" >findtty.c <<'END_OF_findtty.c'
X# include       "sps.h"
X# include       <h/ioctl.h>
X# include       <h/tty.h>
X
X/* FINDTTY - Attempts to determine to which tty a process is connected */
Xstruct ttyline  *findtty ( p )
X
Xregister struct process         *p ;
X
X{
X        register struct ttyline *lp ;
X        extern struct info      Info ;
X        extern struct ttyline   Notty ;
X        extern union userstate  User ;
X
X        if ( !p->pr_p.p_pgrp )
X                return ( &Notty ) ;
X        for ( lp = Info.i_ttyline ; lp->l_name[0] ; lp++ )
X                if ( lp->l_dev == User.u_us.u_ttyd )
X                        return ( lp ) ;
X        return ( &Notty ) ;
X}
END_OF_findtty.c
if test 533 -ne `wc -c <findtty.c`; then
    echo shar: \"findtty.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f flags.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"flags.h\"
else
echo shar: Extracting \"flags.h\" \(2488 characters\)
sed "s/^X//" >flags.h <<'END_OF_flags.h'
X/* Structure holding information specified in the option list ... */
Xunion flaglist
X{
X        char                    *f_chp ;        /* Option specified as string */
X        int                     f_uid ;         /* Numerical user id */
X        int                     f_pid ;         /* Numerical process id */
X        struct ttyline          *f_ttyline ;    /* Specified tty */
X} ;
X
X/* Structure holding global information specifed by arg list options ... */
Xstruct flags
X{
X        int                     flg_d:1 ;       /* disc orientated output */
X        int                     flg_e:1 ;       /* print environment string */
X        int                     flg_f:1 ;       /* print process father # */
X        int                     flg_g:1 ;       /* print process group # */
X        int                     flg_i:1 ;       /* initialise sps */
X        char                    *flg_j ;        /* Use this as the info file */
X        char                    *flg_k ;        /* Use this as the {k}mem file*/
X        int                     flg_o:1 ;       /* avoid the swap device */
X        int                     flg_q:1 ;       /* show user time only */
X        int                     flg_r:1 ;       /* repeat output */
X        unsigned                flg_rdelay ;    /* ... with this much delay */
X        char                    *flg_s ;        /* Use this as the symbol file*/
X        int                     flg_v:1 ;       /* print verbose listing */
X        int                     flg_w:1 ;       /* print wide output */
X        int                     flg_y:1 ;       /* print tty information */
X        int                     flg_A:1 ;       /* print all processes */
X        int                     flg_B:1 ;       /* print busy processes */
X        int                     flg_F:1 ;       /* print foreground processes */
X        int                     flg_N:1 ;       /* print no processes */
X        int                     flg_P:1 ;       /* print specified process #'s*/
X        int                     flg_S:1 ;       /* print stopped processes */
X        int                     flg_T:1 ;       /* print procs for given ttys */
X        int                     flg_U:1 ;       /* print procs for given users*/
X        int                     flg_W:1 ;       /* print waiting processes */
X        int                     flg_Z:1 ;       /* print zombie processes */
X        int                     flg_AZ:1 ;      /* One of A to Z was specified*/
X        union flaglist          *flg_Plist ;    /* List of specified processes*/
X        union flaglist          *flg_Tlist ;    /* List of specified ttys */
X        union flaglist          *flg_Ulist ;    /* List of specified users */
X} ;
END_OF_flags.h
if test 2488 -ne `wc -c <flags.h`; then
    echo shar: \"flags.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f flagsetup.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"flagsetup.c\"
else
echo shar: Extracting \"flagsetup.c\" \(2210 characters\)
sed "s/^X//" >flagsetup.c <<'END_OF_flagsetup.c'
X# include       "sps.h"
X# include       "flags.h"
X# include       <h/ioctl.h>
X# include       <h/tty.h>
X
X/*
X** FLAGSETUP - Replaces any users or processes specified by flagdecode()
X** with numerical equivalents. The lists are terminated by negative values.
X** or null pointers. Ttystatus() must have been previously called to
X** initialise the Info structure with chaos tty values.
X*/
Xflagsetup ()
X{
X        register union flaglist *fp ;
X        register char           *chp ;
X        register int            i ;
X        register struct ttyline *lp ;
X        int                     found ;
X        extern struct flags     Flg ;
X        extern struct info      Info ;
X
X        /* Look for specified users */
X        if ( Flg.flg_U )                
X        {
X                if ( !Flg.flg_Ulist->f_chp )
X                        prexit( "sps - User name was expected after -u flag\n");
X                for ( fp = Flg.flg_Ulist ; chp = fp->f_chp ; fp++ )
X                {
X                        found = 0 ;
X                        for ( i = 0 ; i < MAXUSERID ; i++ )
X                                if ( !strncmp( chp, Info.i_hnames[i].h_uname,
X                                        UNAMELEN ) )
X                                {
X                                        fp->f_uid = Info.i_hnames[i].h_uid ;
X                                        found = 1 ;
X                                        break ;
X                                }
X                        if ( !found )
X                                prexit( "sps - Unknown user: %s\n", chp ) ;
X                }
X                fp->f_uid = -1 ;
X        }
X        /* Look for specified process ids */
X        if ( Flg.flg_P )                
X        {
X                if ( !Flg.flg_Plist->f_chp )
X                        prexit(
X                             "sps - Process id was expected after -p flag\n" ) ;
X                for ( fp = Flg.flg_Plist ; chp = fp->f_chp ; fp++ )
X                {
X                        if ( chp[0] < '0' || chp[0] > '9' )
X                                prexit( "sps - Bad process id: %s\n", chp ) ;
X                        fp->f_pid = atoi( chp ) ;
X                }
X                fp->f_pid = -1 ;
X        }
X        /* Look for specified ttys */
X        if ( !Flg.flg_T )              
X                return ;
X        if ( !Flg.flg_Tlist->f_chp )
X                prexit( "sps - Tty name was expected after -t flag\n" ) ;
X        for ( fp = Flg.flg_Tlist ; chp = fp->f_chp ; fp++ )
X        {       /* Under VMUNIX, all ttys have two character names.
X                   Thus, a flag of the form `t 8' should be expanded to
X                   become `t 08'. */
X                if ( !chp[1] )
X                        chp[1] = chp[0], chp[0] = '0' ;
X                found = 0 ;
X                for ( lp = Info.i_ttyline ; lp->l_name[0] ; lp++ )
X                        if ( !strncmp( chp, lp->l_name, 2 ) )
X                        {
X                                fp->f_ttyline = lp ;
X                                found = 1 ;
X                                break ;
X                        }
X                if ( !found )
X                        prexit( "sps - Unknown tty name: %.2s\n", chp ) ;
X        }
X        fp->f_ttyline = (struct ttyline*)0 ;
X}
END_OF_flagsetup.c
if test 2210 -ne `wc -c <flagsetup.c`; then
    echo shar: \"flagsetup.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f getupage.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"getupage.c\"
else
echo shar: Extracting \"getupage.c\" \(2971 characters\)
sed "s/^X//" >getupage.c <<'END_OF_getupage.c'
X# include       "sps.h"
X# include       <h/vm.h>
X# ifdef BSD42
X# include        <machine/pte.h>
X# else
X# include       <h/pte.h>
X# endif
X# include       <stdio.h>
X
X/*
X** GETUPAGE - Reads the upage for the specified process as well as sufficient
X** page tables entries for reading the command arguments. The pte's are read
X** into the argument `ptetbl'. The upage is read into the external variable
X** `User'. This procedure returns 1 if the upage was successfully read.
X*/
X
X# define        usrpt           (Info.i_usrpt)
X
Xgetupage ( p, ptetbl )
X
Xregister struct process         *p ;
Xregister struct pte             *ptetbl ;
X
X{
X        register int            i ;
X        register int            ncl ;
X        struct pte              pte ;
X        extern struct info      Info ;
X        extern union userstate  User ;
X        extern int              Flmem, Flkmem, Flswap ;
X
X        /* If the process is not loaded, look for the upage on the swap device*/
X        if ( !(p->pr_p.p_flag & SLOAD) )
X        {                              
X# ifdef BSD42
X                swseek( (long)dtob( p->pr_p.p_swaddr ) ) ;
X# else
X                swseek( (long)ctob( p->pr_p.p_swaddr ) ) ;
X# endif
X# ifdef SUN
X                if ( read( Flswap, (char*)&User.u_us, sizeof( union userstate ))
X                != sizeof( union userstate ) )
X# else
X                if ( read( Flswap, (char*)&User.u_us, sizeof( struct user ) )
X                != sizeof( struct user ) )
X# endif
X                {
X                        fprintf( stderr,
X                                "sps - Can't read upage of process %d\n",
X                            p->pr_p.p_pid ) ;
X                        return ( 0 ) ;
X                }
X                return ( 1 ) ;          
X        }                              
X        /* The process is loaded. Locate the process pte's by reading
X           the pte of their base address from system virtual address space. */
X        memseek( Flkmem, (long)&Info.i_usrptmap[ btokmx(p->pr_p.p_p0br)
X                + p->pr_p.p_szpt-1 ] ) ;
X        if ( read( Flkmem, (char*)&pte, sizeof( struct pte ) )
X        != sizeof( struct pte ) )
X        {
X                fprintf( stderr,
X                      "sps - Can't read indir pte for upage of process %d\n",
X                    p->pr_p.p_pid ) ;
X                return ( 0 ) ;
X        }                              
X        /* Now read the process' pte's from physical memory. We need to access
X           sufficient pte's for the upage and for the command arguments. */
X        memseek( Flmem, (long)ctob( pte.pg_pfnum+1 )
X                - (UPAGES+CLSIZE)*sizeof( struct pte ) ) ;
X        if ( read( Flmem, (char*)ptetbl, (UPAGES+CLSIZE)*sizeof( struct pte ) )
X        != (UPAGES+CLSIZE)*sizeof( struct pte ) )
X        {
X                fprintf( stderr, "sps - Can't read page table of process %d\n",
X                        p->pr_p.p_pid ) ;
X                return ( 0 ) ;
X        }
X        /* Now we can read the pages belonging to the upage.
X           Here we read in an entire click at one go. */
X        ncl = (sizeof( struct user ) + NBPG*CLSIZE - 1) / (NBPG*CLSIZE) ;
X        while ( --ncl >= 0 )            
X        {                              
X                i = ncl * CLSIZE ;
X                memseek( Flmem, (long)ctob( ptetbl[ CLSIZE+i ].pg_pfnum ) ) ;
X                if ( read( Flmem, User.u_pg[i], CLSIZE*NBPG ) != CLSIZE*NBPG )
X                {
X                        fprintf( stderr,
X                                "sps - Can't read page 0x%x of process %d\n",
X                                ptetbl[ CLSIZE+i ].pg_pfnum, p->pr_p.p_pid ) ;
X                        return ( 0 ) ;
X                }
X        }
X        return ( 1 ) ;
X}
END_OF_getupage.c
if test 2971 -ne `wc -c <getupage.c`; then
    echo shar: \"getupage.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f globals1.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"globals1.c\"
else
echo shar: Extracting \"globals1.c\" \(720 characters\)
sed "s/^X//" >globals1.c <<'END_OF_globals1.c'
X# include       "sps.h"
X# include       "flags.h"
X
X/* Read/Write Variables global to the code of sps */
X
Xstruct info                     Info ;          /* Information structure */
X
Xstruct flags                    Flg ;           /* Flag options */
X
Xstruct summary                  Summary ;       /* Summary of processes */
X
Xunion  userstate                User ;          /* Upage of one process */
X
Xint                             Flmem, Flkmem, Flswap ; /* File descriptors */
X
Xunsigned                        Termwidth ;     /* Width of output device */
X
Xshort                           Lastpgrp ;      /* Last process pgrp printed */
X
Xshort                           Lastuid ;       /* Last process uid printed */
END_OF_globals1.c
if test 720 -ne `wc -c <globals1.c`; then
    echo shar: \"globals1.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f hashuid.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"hashuid.c\"
else
echo shar: Extracting \"hashuid.c\" \(1441 characters\)
sed "s/^X//" >hashuid.c <<'END_OF_hashuid.c'
X# include       "sps.h"
X
X/* The hashing functions themselves ... */
X# define        HASHFN1( a )            (((unsigned)(a)*91 + 17) % MAXUSERID)
X# define        HASHFN2( a )            (((unsigned)(a) + 47) % MAXUSERID)
X
X/*
X** HASHUID - Returns a pointer to a slot in the hash table that corresponds
X** to the hash table entry for `uid'. It returns a null pointer if there is
X** no such slot.
X*/
Xstruct hashtab  *hashuid ( uid )
X
Xint                             uid ;
X
X{
X        register struct hashtab *hp ;
X        register int            i ;
X        register int            j ;
X        extern struct info      Info ;
X
X        j = HASHFN1( uid ) ;
X        for ( i = 0 ; i < MAXUSERID ; i++ )
X        {
X                hp = &Info.i_hnames[ j ] ;
X                if ( !hp->h_uname[0] )
X                        return ( (struct hashtab*)0 ) ;
X                if ( hp->h_uid == uid )
X                        return ( hp ) ;
X                j = HASHFN2( j ) ;
X        }
X        return ( (struct hashtab*)0 ) ;
X}
X
X/*
X** HASHNEXT - Returns a pointer to the next slot in the hash table that
X** may be use for storing information for `uid'. It returns a null pointer
X** if there are no more free slots available.
X*/
Xstruct hashtab  *hashnext ( uid )
X
Xint                             uid ;
X
X{
X        register struct hashtab *hp ;
X        register int            i ;
X        register int            j ;
X        extern struct info      Info ;
X
X        j = HASHFN1( uid ) ;
X        for ( i = 0 ; i < MAXUSERID ; i++ )
X        {
X                hp = &Info.i_hnames[ j ] ;
X                if ( !hp->h_uname[0] )
X                        return ( hp ) ;
X                j = HASHFN2( j ) ;
X        }
X        return ( (struct hashtab*)0 ) ;
X}
END_OF_hashuid.c
if test 1441 -ne `wc -c <hashuid.c`; then
    echo shar: \"hashuid.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f initialise.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"initialise.c\"
else
echo shar: Extracting \"initialise.c\" \(1905 characters\)
sed "s/^X//" >initialise.c <<'END_OF_initialise.c'
X# include       "sps.h"
X# include       "flags.h"
X# include       <pwd.h>
X# include       <stdio.h>
X
X/*
X** INITIALISE - Called to reset the `Info' structure with new kernel
X** addresses and user and tty information.
X*/
Xinitialise ()
X{
X        register FILE           *fd ;
X        char                    *fileinfo ;
X        extern struct flags     Flg ;
X        extern struct info      Info ;
X        FILE                    *fopen() ;
X
X        fileinfo = Flg.flg_j ? Flg.flg_j : FILE_INFO ;
X        /* Read kernel addresses */
X        initsymbols() ;                
X        /* Read user names */
X        initusers() ;                  
X        (void)umask( ~0644 ) ;          
X        if ( !(fd = fopen( fileinfo, "w" )) )
X        {
X                fprintf( stderr, "sps - Can't create info file %s", fileinfo ) ;
X                sysperror() ;
X        }
X        /* Find tty addresses */
X        inittty() ;                    
X        if ( fwrite( (char*)&Info, sizeof( struct info ), 1, fd ) != 1 )
X        {
X                fprintf( stderr, "sps - Can't write info file %s", fileinfo ) ;
X                sysperror() ;
X                exit( 1 ) ;
X        }
X        (void)fclose( fd ) ;
X        printf( "sps is initialised\n" ) ;
X}
X
X/* INITUSERS - Read the passwd file and fill in the user name arrays */
Xinitusers ()
X{
X        register struct passwd  *pw ;
X        register struct hashtab *hp ;
X        struct passwd           *getpwent() ;
X        char                    *strncpy() ;
X        struct hashtab          *hashuid(), *hashnext() ;
X
X        while ( pw = getpwent() )
X        {       /* For each user in the passwd file, first see if that uid
X                   has been already allocated in the hash table. */
X                if ( hp = hashuid( pw->pw_uid ) )
X                {
X                        fprintf( stderr,
X                   "sps - Names %s and %s conflict in passwd file for uid %d\n",
X                                hp->h_uname, pw->pw_name, pw->pw_uid ) ;
X                        continue ;
X                }
X                /* Try to find a free slot in the hash table and fill it. */
X                if ( !(hp = hashnext( pw->pw_uid )) )
X                        prexit( "sps - Too many users in passwd file\n" ) ;
X                hp->h_uid = pw->pw_uid ;
X                (void)strncpy( hp->h_uname, pw->pw_name, UNAMELEN ) ;
X        }
X        (void)endpwent() ;
X}
END_OF_initialise.c
if test 1905 -ne `wc -c <initialise.c`; then
    echo shar: \"initialise.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f initsymbols.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"initsymbols.c\"
else
echo shar: Extracting \"initsymbols.c\" \(3000 characters\)
sed "s/^X//" >initsymbols.c <<'END_OF_initsymbols.c'
X# include       "sps.h"
X# include       "flags.h"
X# ifdef BSD42
X# include       <sys/file.h>
X# endif
X# include       <nlist.h>
X# include       <stdio.h>
X
X/* INITSYMBOLS - Reads kmem values into the Info structure */
X/*
X** THIS CODE COPIES KMEM VALUES INTO THE INFO STRUCTURE ASSUMING THAT
X** VALUES READ FROM THE KERNEL HAVE TYPE CADDR_T. THEREFORE, WE ARE
X** MAKING THE DUBIOUS ASSUMPTION THAT INTS, POINTERS AND CADDR_T's
X** HAVE IDENTICAL SIZES.
X*/
Xinitsymbols ()
X{
X        register struct nlist   *np ;
X        register struct symbol  *s ;
X        register struct nlist   *np0 ;
X        char                    *filesymbol ;
X        extern int              Flkmem ;
X        extern struct flags     Flg ;
X        extern struct symbol    Symbollist[] ;
X        extern struct info      Info ;
X        char                    *getcore() ;
X        char                    *strncpy() ;
X
X        filesymbol = Flg.flg_s ? Flg.flg_s : FILE_SYMBOL ;
X        /* Find the length of the symbol table */
X        for ( s = Symbollist ; s->s_kname ; s++ )
X                ;
X        /* Construct an nlist structure by copying names from the symbol table*/
X        np0 = (struct nlist*)getcore( (s-Symbollist+1)*sizeof( struct nlist ) );
X        for ( s = Symbollist, np = np0 ; s->s_kname ; s++, np++ )
X        {                                      
X                np->n_name = s->s_kname ;      
X                np[1].n_name = (char*)0 ;      
X                np->n_value = 0 ;
X        }
X# ifdef BSD42
X        if ( access( filesymbol, R_OK ) < 0 )
X# else
X        if ( access( filesymbol, 4 ) < 0 )
X# endif
X        {
X                fprintf( stderr, "sps - Can't open symbol file %s", filesymbol);
X                sysperror() ;
X        }
X        /* Get kernel addresses */
X        (void)nlist( filesymbol, np0 ) ;              
X        if ( np0[0].n_value == -1 )
X        {
X                fprintf( stderr, "sps - Can't read symbol file %s", filesymbol);
X                sysperror() ;
X        }
X        for ( s = Symbollist, np = np0 ; s->s_kname ; s++, np++ )
X        {                                      
X                if ( !np->n_value )            
X                {
X                        fprintf( stderr, "sps - Can't find symbol %s in %s",
X                                np->n_name, filesymbol ) ;
X                        /* Assume this error to be unimportant if the address
X                           is only associated with a process wait state.
X                           This may happen if the system has been configured
X                           without a particular device. */
X                        fprintf( stderr, &Info.i_waitstate[ 0 ] <= s->s_info
X                                && s->s_info < &Info.i_waitstate[ NWAITSTATE ]
X                                ? " (error is not serious)\n"
X                                : " (ERROR MAY BE SERIOUS)\n" ) ;
X                        *s->s_info = (caddr_t)0 ;
X                        continue ;
X                }
X                /* If no indirection is required, just copy the obtained value
X                   into the `Info' structure. */
X                if ( !s->s_indirect )          
X                {                              
X                /* DUBIOUS ASSUMPTION THAT KMEM VALUE HAS SIZE OF A CADDR_T */
X                        *s->s_info = (caddr_t)np->n_value ;
X                        continue ;              
X                }                              
X                /* Otherwise one level of indirection is required. Using the
X                   obtained address, look again in the kernel for the value */
X                memseek( Flkmem, (long)np->n_value ) ;
X                /* DUBIOUS ASSUMPTION THAT KMEM VALUE HAS SIZE OF A CADDR_T */
X                (void)read( Flkmem, (char*)s->s_info, sizeof(caddr_t) ) ;
X        }
X        free( (char*)np0 ) ;
X}
END_OF_initsymbols.c
if test 3000 -ne `wc -c <initsymbols.c`; then
    echo shar: \"initsymbols.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f main.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"main.c\"
else
echo shar: Extracting \"main.c\" \(3406 characters\)
sed "s/^X//" >main.c <<'END_OF_main.c'
X# include       "sps.h"
X# include       "flags.h"
X# include       <h/text.h>
X# include       <sys/stat.h>
X# include       <stdio.h>
X
X
X/* SPS - Show Process Status */
X/* J. R. Ward - Hasler AG Bern, CH - 24 May 1985 */
X/*                                     26 Nov 1986 */
X
X/* <robert@hslrswi.uucp> */
X
Xmain ( argc,argv )
X
Xint                             argc ;
Xchar                            **argv ;
X
X{
X        register struct process *plist ;
X        register struct process *process ;
X        register struct text    *text ;
X        int                     flinfo ;
X        char                        *fileinfo, *filesymbol ;
X        struct stat                sinfo, ssymbol, spasswd ;
X        extern struct flags     Flg ;
X        extern struct info      Info ;
X        extern int              Flmem ;
X        extern int              Flkmem ;
X        extern int              Flswap ;
X        char                    *getcore() ;
X        struct process          *needed(), *mktree() ;
X
X        /* Renice as fast as possible for root only (Suggested by Jeff Mogul,
X           gregorio!mogul) */
X        if ( !getuid() )
X                (void)nice( -40 ) ;
X        /* Decode the flag arguments */
X        flagdecode( argc, argv ) ;      
X        /* Determine the terminal width */
X        if ( !Flg.flg_w && !Flg.flg_N && !Flg.flg_i )
X                termwidth() ;
X        /* Open the cpu physical memory, kernel virtual memory and swap device*/
X        if ( Flg.flg_k )
X        {
X                Flmem = openfile( Flg.flg_k ) ;
X                Flkmem = Flmem ;
X        }
X        else
X        {
X                Flmem = openfile( FILE_MEM ) ;
X                Flkmem = openfile( FILE_KMEM ) ;
X                if ( !Flg.flg_o )
X                        Flswap = openfile( FILE_SWAP ) ;
X        }
X        if ( Flg.flg_i )
X        {       /* -i flag for info file initialisation */
X                initialise() ;          
X                exit( 0 ) ;
X        }
X        /* Check that the information file is newer than the symbol and
X           password files, suggested by gregorio!mogul */
X        fileinfo = Flg.flg_j ? Flg.flg_j : FILE_INFO ;
X        filesymbol = Flg.flg_s ? Flg.flg_s : FILE_SYMBOL ;
X        flinfo = openfile( fileinfo ) ;
X        (void)fstat( flinfo, &sinfo ) ;
X        if ( !stat( filesymbol, &ssymbol ) &&
X                sinfo.st_mtime < ssymbol.st_mtime )
X                fprintf( stderr,
X               "sps - WARNING: Info file `%s' is older than symbol file `%s'\n",
X                        fileinfo, filesymbol ) ;
X        if ( !stat( FILE_PASSWD, &spasswd ) &&
X                sinfo.st_mtime < spasswd.st_mtime )
X                fprintf( stderr,
X               "sps - WARNING: Info file `%s' is older than passwd file `%s'\n",
X                        fileinfo, FILE_PASSWD ) ;
X        /* Read the information file */
X        if ( read( flinfo, (char*)&Info, sizeof( struct info ) )
X        != sizeof( struct info ) )
X        {
X                fprintf( stderr, "sps - Can't read info file `%s'", fileinfo ) ;
X                sysperror() ;
X        }
X        (void)close( flinfo ) ;
X        /* Find current tty status */
X        ttystatus() ;                  
X        /* Now that we know the available ttys, decode the flags */
X        flagsetup() ;                  
X        process = (struct process*)getcore(Info.i_nproc*sizeof(struct process));
X        text = (struct text*)getcore( Info.i_ntext * sizeof( struct text ) ) ;
X        do
X        {       /* Read current process and text status */
X                readstatus( process, text ) ;
X                /* Select those processes to be listed */
X                plist = needed( process, text ) ;
X                /* Form a tree of listed processes */
X                plist = mktree( process, plist ) ;
X                if ( !Flg.flg_N )
X                {       /* Print the processes */
X                        prheader() ;
X                        printall( plist, 0 ) ;
X                }
X                prsummary() ;
X                (void)fflush( stdout ) ;
X                if ( Flg.flg_r )        
X                {       /* If repeating, again get tty status */
X                        ttystatus() ;
X                        if ( Flg.flg_rdelay )
X# ifdef BSD42
X                                sleep( Flg.flg_rdelay ) ;
X# else
X                                sleep( (int)Flg.flg_rdelay ) ;
X# endif
X                }
X        } while ( Flg.flg_r ) ;
X        exit( 0 ) ;
X}
END_OF_main.c
if test 3406 -ne `wc -c <main.c`; then
    echo shar: \"main.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f mktree.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"mktree.c\"
else
echo shar: Extracting \"mktree.c\" \(1626 characters\)
sed "s/^X//" >mktree.c <<'END_OF_mktree.c'
X# include       "sps.h"
X
X/*
X** MKTREE - Sort the needed processes by subtree and at the top by user.
X** This procedure takes a list of processes (as returned by needed())
X** and returnes a pointer to a sorted list.
X*/
Xstruct process  *mktree ( process, plist )
X
Xstruct process                  *process ;
Xstruct process                  *plist ;
X
X{
X        register struct process *p ;
X        register struct process *pp ;
X        register struct process *lp ;
X        struct process          *op ;
X        struct process          proot ;
X
X        proot.pr_sibling = (struct process*)0 ;
X        for ( p = plist ; p ; p = p->pr_plink )
X        {
X                if ( p->pr_pptr > &process[1] )
X                {
X                        for ( pp = plist ; pp ; pp = pp->pr_plink )
X                        {
X                                if ( pp != p->pr_pptr )
X                                        continue ;
X                                if ( lp = pp->pr_child )
X                                {       /* Does process have children ? */
X                                        op = (struct process*)0 ;
X                                        while (lp &&
X                                        lp->pr_p.p_pid < p->pr_p.p_pid )
X                                        {
X                                                op = lp ;
X                                                lp=lp->pr_sibling ;
X                                        }
X                                        if ( op )
X                                        {
X                                                p->pr_sibling = lp ;
X                                                op->pr_sibling = p ;
X                                                break ;
X                                        }
X                                }      
X                                p->pr_sibling = lp ;
X                                pp->pr_child = p ;
X                                break ;
X                        }
X                        if ( pp )
X                                continue ;
X                }
X                /* We have a top level process, sort into top level list.
X                   The top level is sorted firstly by user-id and then
X                   by process-id. */
X                lp = &proot ;
X                pp = lp->pr_sibling ;
X                while ( pp )
X                {
X                        if ( p->pr_p.p_uid < pp->pr_p.p_uid )
X                                break ;
X                        if ( p->pr_p.p_uid == pp->pr_p.p_uid
X                        && p->pr_p.p_pid < pp->pr_p.p_pid )
X                                break ;
X                        lp = pp, pp = pp->pr_sibling ;
X                }
X                p->pr_sibling = lp->pr_sibling ;
X                lp->pr_sibling = p ;
X        }
X        return ( proot.pr_sibling ) ;
X}
END_OF_mktree.c
if test 1626 -ne `wc -c <mktree.c`; then
    echo shar: \"mktree.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f openfiles.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"openfiles.c\"
else
echo shar: Extracting \"openfiles.c\" \(2626 characters\)
sed "s/^X//" >openfiles.c <<'END_OF_openfiles.c'
X# include       <stdio.h>
X# include       "sps.h"
X# include       "flags.h"
X
X/* Miscellaneous procedures */
X
X/* OPENFILE - Opens the named file */
Xopenfile ( name )
X
Xchar                            *name ;
X
X{
X        register int            fd ;
X
X        if ( (fd = open( name, 0 )) >= 0 )
X                return ( fd ) ;
X        fprintf( stderr, "sps - Can't open %s", name ) ;
X        sysperror() ;
X        /* NOTREACHED */
X}
X
X/* MEMSEEK - Seek on a special file */
Xmemseek ( fd, pos )
X
Xint                             fd ;
Xlong                            pos ;
X
X{
X        extern int              errno ;
X        extern struct flags     Flg ;
X        long                    lseek() ;
X
X        errno = 0 ;
X        if ( Flg.flg_k )
X                pos &= 0x7fffffff ;
X        (void)lseek( fd, pos, 0 ) ;
X        if ( errno )
X        {
X                fprintf( stderr, "sps - Seek failed" ) ;
X                sysperror() ;
X        }
X}
X
X/* SWSEEK - Seek on the swap device */
Xswseek ( pos )
X
Xlong                            pos ;
X
X{
X        extern int              Flswap ;
X        extern int              errno ;
X        long                    lseek() ;
X
X        errno = 0 ;
X        (void)lseek( Flswap, pos, 0 ) ;
X        if ( errno )
X        {
X                fprintf( stderr, "sps - Seek failed" ) ;
X                sysperror() ;
X        }
X}
X
X# ifdef lint
Xint                             errno ;
Xint                             sys_nerr ;
Xchar                            *sys_errlist[] ;
X# endif
X
X/* SYSPERROR - Reports a system defined error msg and then exits gracefully */
Xsysperror ()
X{
X        extern int              errno ;
X        extern int              sys_nerr ;
X        extern char             *sys_errlist[] ;
X
X        if ( 0 < errno && errno < sys_nerr )
X                fprintf( stderr, " : %s", sys_errlist[errno] ) ;
X        (void)fputc( '\n', stderr ) ;
X        exit( 1 ) ;
X}
X
X/* STRSAVE - Store a string in core for later use. */
Xchar    *strsave ( cp )
X
Xregister char                   *cp ;
X
X{
X        register char           *chp ;
X        char                    *getcore(), *strcpy() ;
X
X        chp = getcore( strlen( cp ) + 1 ) ;
X        (void)strcpy( chp, cp ) ;
X        return ( chp ) ;
X}
X
X/* GETCORE - Allocate and return a pointer to the asked for amount of core */
Xchar    *getcore ( size )
X
Xregister int                    size ;
X
X{
X        register char           *chp ;
X        char                    *malloc() ;
X
X        if ( chp = malloc( (unsigned)size ) )
X                return ( chp ) ;
X        fprintf( stderr, "sps - Out of core" ) ;
X        sysperror() ;
X        /* NOTREACHED */
X}
X
Xunion flaglist  *getflgsp ( argc )
X
Xregister int                    argc ;
X
X{
X        char                    *getcore() ;
X
X        return ( (union flaglist*)getcore( sizeof( union flaglist )*argc ) ) ;
X}
X
X/* PREXIT - Print an error message and exit */
X/* VARARGS1 */
X/* ARGSUSED */
Xprexit ( fmt, args )
X
Xchar                            *fmt ;
X
X{
X        _doprnt( fmt, &args, stderr ) ;
X        exit( 1 ) ;
X}
END_OF_openfiles.c
if test 2626 -ne `wc -c <openfiles.c`; then
    echo shar: \"openfiles.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f percentmem.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"percentmem.c\"
else
echo shar: Extracting \"percentmem.c\" \(823 characters\)
sed "s/^X//" >percentmem.c <<'END_OF_percentmem.c'
X# include       "sps.h"
X# include       <h/text.h>
X# ifdef BSD42
X# include        <machine/pte.h>
X# else
X# include       <h/pte.h>
X# include       <h/vmparam.h>
X# endif
X# include       <h/vmmac.h>
X
X/* PERCENTMEM - Returns the percentage of real memory used by this process */
Xdouble  percentmem ( p )
X
Xregister struct process         *p ;
X
X{
X        register struct text    *tp ;
X        int                     szptudot ;
X        double                  fracmem ;
X        extern struct info      Info ;
X
X        tp = p->pr_p.p_textp ;
X        if ( !(p->pr_p.p_flag & SLOAD) || !tp )
X                return ( 0.0 ) ;
X        szptudot = UPAGES + clrnd( ctopt( p->pr_p.p_dsize + p->pr_p.p_ssize ) );
X        fracmem = ( (double)p->pr_p.p_rssize + szptudot ) / CLSIZE ;
X        if ( tp->x_ccount )
X                fracmem += ((double)tp->x_rssize)/CLSIZE/tp->x_ccount ;
X        return ( 100.0 * fracmem / (double)Info.i_ecmx ) ;
X}
END_OF_percentmem.c
if test 823 -ne `wc -c <percentmem.c`; then
    echo shar: \"percentmem.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f prcmd.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"prcmd.c\"
else
echo shar: Extracting \"prcmd.c\" \(709 characters\)
sed "s/^X//" >prcmd.c <<'END_OF_prcmd.c'
X# include       "sps.h"
X# include       "flags.h"
X
X/* PRCMD - Prints the command arguments according to the switches */
Xprcmd ( p, lpad, width )
X
Xregister struct process         *p ;
Xint                             lpad ;
Xint                             width ;
X
X{
X        extern struct flags     Flg ;
X        extern unsigned         Termwidth ;
X
X        printf( "%*d ", lpad, p->pr_p.p_pid ) ;
X        if ( Flg.flg_f )
X        {
X                printf( "%5d ", p->pr_p.p_ppid ) ;
X                width -= 6 ;
X        }
X        if ( Flg.flg_g )
X        {
X                printf( "%5d ", p->pr_p.p_pgrp ) ;
X                width -= 6 ;
X        }
X        width += Termwidth ;
X        if ( Flg.flg_w )
X                printf( "%s\n", p->pr_cmd ) ;
X        else if ( width > 0 )
X                printf( "%-.*s\n", width, p->pr_cmd ) ;
X        if ( p->pr_csaved )
X                free( p->pr_cmd ) ;
X}
END_OF_prcmd.c
if test 709 -ne `wc -c <prcmd.c`; then
    echo shar: \"prcmd.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f prcpu.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"prcpu.c\"
else
echo shar: Extracting \"prcpu.c\" \(1538 characters\)
sed "s/^X//" >prcpu.c <<'END_OF_prcpu.c'
X# include       "sps.h"
X
X# ifdef BSD42
X
X/* PRCPU - Print cpu time */
Xprcpu ( time, utime )
X
Xregister time_t                 time ;
Xtime_t                          utime ;
X
X{
X        time += utime / 1000000 ;
X        utime %= 1000000 ;
X        if ( time < 0L )
X        {       /* Ignore negative times */
X                printf( "     " ) ;    
X                return ;
X        }
X        if ( time < 60L*10L )
X        {       /* Print as seconds if less than 1000 seconds */
X                printf( "%3d.%1d", (int)time, (int)utime/100000 ) ;
X                return ;
X        }
X        /* Print as minutes if less than 10 hours ; print as hours if less than
X           10 days, else print as days. */
X        if ( time < 60L*60L*10L )              
X                printf( "%3D M", time/60L ) ;
X        else if ( time < 24L*60L*60L*10L )
X                printf( "%3D H", time/60L/60L ) ;
X        else
X                printf( "%3D D", time/60L/60L/24L ) ;
X}
X
X# else
X
X/* PRCPU - Print cpu time */
Xprcpu ( time )
X
Xregister time_t                 time ;
X
X{
X        extern struct info      Info ;
X
X        if ( time < 0L )
X        {       /* Ignore negative times */
X                printf( "     " ) ;    
X                return ;
X        }
X        if ( time < Info.i_hz*60L*10L )
X        {       /* Less than 10 minutes */
X                printf( "%3D.%1D", time/Info.i_hz,
X                        (time % Info.i_hz / (Info.i_hz/10L)) ) ;
X                return ;
X        }
X        /* If less than 10 hours, print as minutes */
X        time /= Info.i_hz ;
X        /* Print as minutes if less than 10 hours ; print as hours if less than
X           10 days, else print as days. */
X        if ( time < 60L*60L*10L )              
X                printf( "%3D M", time/60L ) ;
X        else if ( time < 24L*60L*60L*10L )
X                printf( "%3D H", time/60L/60L ) ;
X        else
X                printf( "%3D D", time/60L/60L/24L ) ;
X}
X
X# endif
END_OF_prcpu.c
if test 1538 -ne `wc -c <prcpu.c`; then
    echo shar: \"prcpu.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f prheader.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"prheader.c\"
else
echo shar: Extracting \"prheader.c\" \(438 characters\)
sed "s/^X//" >prheader.c <<'END_OF_prheader.c'
X# include       "sps.h"
X# include       "flags.h"
X
X/* PRHEADER - Print a header according to the switches */
Xprheader ()
X{
X        extern struct flags     Flg ;
X
X        printf( "Ty User    %s Proc#", Flg.flg_v ?
X                " Status Fl Nice Virtual Resident %M  Time Child %C" :
X                Flg.flg_d ?
X                "  Files    PageFaults Swap BlockI/O Kbytsecs" : "" ) ;
X        if ( Flg.flg_f )
X                printf( " Ppid#" ) ;
X        if ( Flg.flg_g )
X                printf( " Pgrp#" ) ;
X        printf( " Command\n" ) ;
X}
END_OF_prheader.c
if test 438 -ne `wc -c <prheader.c`; then
    echo shar: \"prheader.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f printall.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"printall.c\"
else
echo shar: Extracting \"printall.c\" \(430 characters\)
sed "s/^X//" >printall.c <<'END_OF_printall.c'
X# include       <stdio.h>
X# include       "sps.h"
X
X/* PRINTALL - Recursively print the process tree. */
Xprintall ( p, md )
X
Xregister struct process         *p ;
Xregister int                    md ;
X
X{
X        while ( p )
X        {       /* Print this process */
X                printproc( p, md ) ;    
X                (void)fflush( stdout ) ;
X                /* Print child processes */
X                printall( p->pr_child, md+1 ) ;
X                /* Print brother processes */
X                p = p->pr_sibling ;    
X        }
X}
END_OF_printall.c
if test 430 -ne `wc -c <printall.c`; then
    echo shar: \"printall.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f prsummary.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"prsummary.c\"
else
echo shar: Extracting \"prsummary.c\" \(632 characters\)
sed "s/^X//" >prsummary.c <<'END_OF_prsummary.c'
X# include       "sps.h"
X
X/* PRSUMMARY - Print the summarising information */
Xprsummary ()
X{
X        extern struct summary   Summary ;
X
X        printf(
X"%D (%Dk) processes, %D (%Dk) busy, %D (%Dk) loaded, %D (%Dk) swapped\n",
X                Summary.sm_ntotal, KBYTES( Summary.sm_ktotal ),
X                Summary.sm_nbusy, KBYTES( Summary.sm_kbusy ),
X                Summary.sm_nloaded, KBYTES( Summary.sm_kloaded ),
X                Summary.sm_nswapped, KBYTES( Summary.sm_kswapped ) ) ;
X        Summary.sm_ntotal = 0L ;
X        Summary.sm_ktotal = 0L ;
X        Summary.sm_nbusy = 0L ;
X        Summary.sm_kbusy = 0L ;
X        Summary.sm_nloaded = 0L ;
X        Summary.sm_kloaded = 0L ;
X        Summary.sm_nswapped = 0L ;
X        Summary.sm_kswapped = 0L ;
X}
END_OF_prsummary.c
if test 632 -ne `wc -c <prsummary.c`; then
    echo shar: \"prsummary.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f readstatus.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"readstatus.c\"
else
echo shar: Extracting \"readstatus.c\" \(1170 characters\)
sed "s/^X//" >readstatus.c <<'END_OF_readstatus.c'
X# include       "sps.h"
X# include       <h/text.h>
X
X/* READSTATUS - Reads the kernel memory for current processes and texts */
Xreadstatus ( process, text )
X
Xregister struct process         *process ;
Xstruct text                     *text ;
X
X{
X        register struct proc    *p ;
X        register struct proc    *p0 ;
X        register struct process *pr ;
X        extern struct info      Info ;
X        extern int              Flkmem ;
X        char                    *getcore() ;
X
X        /* Read current text information */
X        memseek( Flkmem, (long)Info.i_text0 ) ;
X        if ( read( Flkmem, (char*)text, Info.i_ntext * sizeof( struct text ) )
X        != Info.i_ntext * sizeof( struct text ) )
X                prexit( "sps - Can't read system text table\n" ) ;
X        /* Read current process information */
X        p0 = (struct proc*)getcore( sizeof( struct proc )*Info.i_nproc ) ;
X        memseek( Flkmem, (long)Info.i_proc0 ) ;
X        if ( read( Flkmem, (char*)p0, Info.i_nproc * sizeof( struct proc ) )
X        != Info.i_nproc * sizeof( struct proc ) )
X                prexit( "sps - Can't read system process table\n" ) ;
X        /* Copy process information into our own array */
X        for ( p = p0, pr = process ; pr < &process[ Info.i_nproc ] ; p++, pr++ )
X                pr->pr_p = *p ;
X        free( (char*)p0 ) ;
X}
END_OF_readstatus.c
if test 1170 -ne `wc -c <readstatus.c`; then
    echo shar: \"readstatus.c\" unpacked with wro...