home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume10 / sps / part01 next >
Internet Message Format  |  1987-07-21  |  62KB
  1. Path: uunet!rs
  2. From: rs@uunet.UU.NET (Rich Salz)
  3. Newsgroups: comp.sources.unix
  4. Subject: v10i060:  SPS for BSD, Ultrix1.2, Sun3.x, NFS, Part01/03
  5. Message-ID: <689@uunet.UU.NET>
  6. Date: 23 Jul 87 00:17:15 GMT
  7. Organization: UUNET Communications Services, Arlington, VA
  8. Lines: 2004
  9. Approved: rs@uunet.UU.NET
  10.  
  11. Submitted-by: robert@hslrswi.UUCP (Robert Ward)
  12. Posting-Number: Volume 10, Issue 60
  13. Archive-name: sps/Part01
  14.  
  15. [  This is a fast, public, version of "ps" for BSD-derived Unices..  --r$  ]
  16.  
  17. Hello Net,
  18.  
  19. This is another posting of SPS, hopefully the last for quite a while now.
  20. This version is the same as the one last posted to comp.sources.unix
  21. except that it includes fixes for those 4.3 systems with NFS. These
  22. additions were incorporated by Alexander Dupuy <dupuy@amsterdam.columbia.edu>
  23. who writes:
  24.  
  25. > Sun-specific changes
  26. > 
  27. >     A minor bugfix to "getcmd.c" to deal with processes which have no stack
  28. > (this is the case for nfs async block i/o daemons on some VMEbus Suns).
  29. > 
  30. > 
  31. > 4.3+NFS changes
  32. > 
  33. >     Changes to conditionalization to support NFS on non-Sun systems.
  34. > Several things like disc quotas are reimplemented with NFS, and should be
  35. > ignored on any NFS system, not just Suns.  The files "globals2.c" and
  36. > "waitingfor.c" were changed to support non-Sun NFS systems.  The file
  37. > "Makefile.sun" was changed to add the -DNFS option, and a new Makefile for
  38. > 4.3+NFS systems was added.
  39. > 
  40. >                     Alexander Dupuy
  41.  
  42.  
  43.  
  44. As usual, please mail all comments and fixes to myself (Robert) at:
  45.  
  46. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  47.     J. Robert Ward,                           ___________
  48.     Hasler AG, Belpstrasse 23, CH-3000 Berne 14, Switzerland       |    _    |
  49.                                    |  _| |_  |
  50. Tel.:        +41 31 632319                       | |_   _| |
  51. X.400:        robert@hslrswi.hasler                   |   |_|   |
  52. Bitnet:        robert%hslrswi.UUCP@cernvax.BITNET                  |_________|
  53. Uucp:        ... {seismo,ukc, ... }!mcvax!cernvax!hslrswi!robert
  54. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  55. #! /bin/sh
  56. # This is a shell archive.  Remove anything before this line, then unpack
  57. # it by saving it into a file and typing "sh file".  To overwrite existing
  58. # files, type "sh file -c".  You can also feed this as standard input via
  59. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  60. # will see the following message at the end:
  61. #        "End of archive 1 (of 3)."
  62. # Contents:  MANIFEST Makefile.4.1 Makefile.4.2 Makefile.4.3
  63. #   Makefile.4.3+NFS Makefile.sun README README2 filecount.c findtty.c
  64. #   flags.h flagsetup.c getupage.c globals1.c hashuid.c initialise.c
  65. #   initsymbols.c main.c mktree.c openfiles.c percentmem.c prcmd.c
  66. #   prcpu.c prheader.c printall.c prsummary.c readstatus.c
  67. #   selectproc.c selecttty.c termwidth.c ttystatus.c
  68. # Wrapped by rs@uunet on Wed Jul 22 20:09:05 1987
  69. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  70. if test -f MANIFEST -a "${1}" != "-c" ; then 
  71.   echo shar: Will not over-write existing file \"MANIFEST\"
  72. else
  73. echo shar: Extracting \"MANIFEST\" \(1344 characters\)
  74. sed "s/^X//" >MANIFEST <<'END_OF_MANIFEST'
  75. X   File Name        Archive #    Description
  76. X-----------------------------------------------------------
  77. X MANIFEST                  1    This shipping list
  78. X Makefile.4.1              1    
  79. X Makefile.4.2              1    
  80. X Makefile.4.3              1    
  81. X Makefile.4.3+NFS          1    
  82. X Makefile.sun              1    
  83. X README                    1    
  84. X README2                   1    
  85. X filecount.c               1    
  86. X findtty.c                 1    
  87. X flagdecode.c              2    
  88. X flags.h                   1    
  89. X flagsetup.c               1    
  90. X getcmd.c                  2    
  91. X getupage.c                1    
  92. X globals1.c                1    
  93. X globals2.c                2    
  94. X hashuid.c                 1    
  95. X initialise.c              1    
  96. X initsymbols.c             1    
  97. X inittty.c                 2    
  98. X main.c                    1    
  99. X mktree.c                  1    
  100. X needed.c                  2    
  101. X openfiles.c               1    
  102. X patches                   3    
  103. X percentmem.c              1    
  104. X prcmd.c                   1    
  105. X prcpu.c                   1    
  106. X prheader.c                1    
  107. X printall.c                1    
  108. X printproc.c               2    
  109. X prsummary.c               1    
  110. X readstatus.c              1    
  111. X selectproc.c              1    
  112. X selecttty.c               1    
  113. X sps.h                     2    
  114. X sps.man                   3    
  115. X termwidth.c               1    
  116. X ttystatus.c               1    
  117. X waitingfor.c              2    
  118. END_OF_MANIFEST
  119. if test 1344 -ne `wc -c <MANIFEST`; then
  120.     echo shar: \"MANIFEST\" unpacked with wrong size!
  121. fi
  122. # end of overwriting check
  123. fi
  124. if test -f Makefile.4.1 -a "${1}" != "-c" ; then 
  125.   echo shar: Will not over-write existing file \"Makefile.4.1\"
  126. else
  127. echo shar: Extracting \"Makefile.4.1\" \(882 characters\)
  128. sed "s/^X//" >Makefile.4.1 <<'END_OF_Makefile.4.1'
  129. X# Makefile for SPS (4.1BSD UNIX Version)
  130. X
  131. XPROG    =       sps
  132. XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
  133. X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
  134. X        initialise.o initsymbols.o inittty.o main.o mktree.o \
  135. X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
  136. X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
  137. X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
  138. X
  139. XINCS    =       sps.h
  140. XLIBS    =       -ltermlib
  141. XCFLAGS  =       -I/usr/src/sys -DCHAOS
  142. X
  143. Xall:            $(PROG)
  144. X.c.o:
  145. X        cc $(CFLAGS) -c -O -R $<
  146. Xglobals1.o waitingfor.o:
  147. X        cc $(CFLAGS) -c -O $<
  148. X
  149. X$(OBJS):        $(INCS)
  150. X
  151. X$(PROG):        $(OBJS)
  152. X        cc -o $@ $(OBJS) $(LIBS)
  153. X
  154. Xinstall:        $(PROG)
  155. X        strip $(PROG)
  156. X        mv $(PROG) /bin/$(PROG)
  157. X        /etc/chown root /bin/$(PROG)
  158. X        chmod 4711 /bin/$(PROG)
  159. X
  160. Xlint:
  161. X        lint -x -b $(CFLAGS) *.c
  162. Xclean:
  163. X        rm -f $(OBJS) $(PROG)
  164. END_OF_Makefile.4.1
  165. if test 882 -ne `wc -c <Makefile.4.1`; then
  166.     echo shar: \"Makefile.4.1\" unpacked with wrong size!
  167. fi
  168. # end of overwriting check
  169. fi
  170. if test -f Makefile.4.2 -a "${1}" != "-c" ; then 
  171.   echo shar: Will not over-write existing file \"Makefile.4.2\"
  172. else
  173. echo shar: Extracting \"Makefile.4.2\" \(977 characters\)
  174. sed "s/^X//" >Makefile.4.2 <<'END_OF_Makefile.4.2'
  175. X# Makefile for SPS (Vax 4.2BSD and Ultrix1.2 UNIX Version)
  176. X
  177. XPROG    =       sps
  178. XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
  179. X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
  180. X        initialise.o initsymbols.o inittty.o main.o mktree.o \
  181. X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
  182. X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
  183. X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
  184. XINCS    =       sps.h
  185. XCC      =       cc
  186. XCFLAGS  =       -DBSD42 -I/sys
  187. XLIBS    =       -ltermlib
  188. XDIRINSTALL =    /bin
  189. X
  190. Xall:            $(PROG)
  191. X.c.o:
  192. X        $(CC) $(CFLAGS) -c -O -R $<
  193. X    
  194. Xglobals1.o waitingfor.o:
  195. X        $(CC) $(CFLAGS) -c -O $<
  196. X
  197. X$(OBJS):        $(INCS)
  198. X
  199. X$(PROG):        $(OBJS)
  200. X        $(CC) -o $@ $(OBJS) $(LIBS)
  201. X
  202. Xinstall:        $(PROG)
  203. X        strip $(PROG)
  204. X        mv $(PROG) $(DIRINSTALL)/$(PROG)
  205. X        /etc/chown root $(DIRINSTALL)/$(PROG)
  206. X        chgrp kmem $(DIRINSTALL)/$(PROG)
  207. X        chmod 2755 $(DIRINSTALL)/$(PROG)
  208. X
  209. Xlint:
  210. X        lint -x -b $(CFLAGS) *.c
  211. Xclean:
  212. X        rm -f $(OBJS) $(PROG)
  213. END_OF_Makefile.4.2
  214. if test 977 -ne `wc -c <Makefile.4.2`; then
  215.     echo shar: \"Makefile.4.2\" unpacked with wrong size!
  216. fi
  217. # end of overwriting check
  218. fi
  219. if test -f Makefile.4.3 -a "${1}" != "-c" ; then 
  220.   echo shar: Will not over-write existing file \"Makefile.4.3\"
  221. else
  222. echo shar: Extracting \"Makefile.4.3\" \(966 characters\)
  223. sed "s/^X//" >Makefile.4.3 <<'END_OF_Makefile.4.3'
  224. X# Makefile for SPS (Vax 4.3BSD Version)
  225. X
  226. XPROG    =       sps
  227. XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
  228. X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
  229. X        initialise.o initsymbols.o inittty.o main.o mktree.o \
  230. X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
  231. X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
  232. X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
  233. XINCS    =       sps.h
  234. XCC      =       cc
  235. XCFLAGS  =       -DBSD42 -DBSD43 -I/sys
  236. XLIBS    =       -ltermlib
  237. XDIRINSTALL =    /bin
  238. X
  239. Xall:            $(PROG)
  240. X.c.o:
  241. X        $(CC) $(CFLAGS) -c -O -R $<
  242. X    
  243. Xglobals1.o waitingfor.o:
  244. X        $(CC) $(CFLAGS) -c -O $<
  245. X
  246. X$(OBJS):        $(INCS)
  247. X
  248. X$(PROG):        $(OBJS)
  249. X        $(CC) -o $@ $(OBJS) $(LIBS)
  250. X
  251. Xinstall:        $(PROG)
  252. X        strip $(PROG)
  253. X        mv $(PROG) $(DIRINSTALL)/$(PROG)
  254. X        /etc/chown root $(DIRINSTALL)/$(PROG)
  255. X        chgrp kmem $(DIRINSTALL)/$(PROG)
  256. X        chmod 2755 $(DIRINSTALL)/$(PROG)
  257. X
  258. Xlint:
  259. X        lint -x -b $(CFLAGS) *.c
  260. Xclean:
  261. X        rm -f $(OBJS) $(PROG)
  262. END_OF_Makefile.4.3
  263. if test 966 -ne `wc -c <Makefile.4.3`; then
  264.     echo shar: \"Makefile.4.3\" unpacked with wrong size!
  265. fi
  266. # end of overwriting check
  267. fi
  268. if test -f Makefile.4.3+NFS -a "${1}" != "-c" ; then 
  269.   echo shar: Will not over-write existing file \"Makefile.4.3+NFS\"
  270. else
  271. echo shar: Extracting \"Makefile.4.3+NFS\" \(1089 characters\)
  272. sed "s/^X//" >Makefile.4.3+NFS <<'END_OF_Makefile.4.3+NFS'
  273. X# Makefile for SPS (Vax 4.3BSD Version)
  274. XPROG    =       sps
  275. XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
  276. X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
  277. X        initialise.o initsymbols.o inittty.o main.o mktree.o \
  278. X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
  279. X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
  280. X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
  281. XINCS    =       sps.h
  282. XCC      =       cc
  283. XCFLAGS  =       -DBSD42 -DBSD43 -DQUOTA -DNFS -I/sys
  284. XLIBS    =       -ltermlib
  285. XDIRINSTALL =    /bin
  286. Xall:            $(PROG)
  287. X.c.o:
  288. X        $(CC) $(CFLAGS) -c -O -R $<
  289. Xglobals1.o waitingfor.o:
  290. X        $(CC) $(CFLAGS) -c -O $<
  291. X$(OBJS):        $(INCS)
  292. X$(PROG):        $(OBJS)
  293. X        $(CC) -o $@ $(OBJS) $(LIBS)
  294. Xinstall:        $(PROG)
  295. X        strip $(PROG)
  296. X        mv $(PROG) $(DIRINSTALL)/$(PROG)
  297. X        /etc/chown root $(DIRINSTALL)/$(PROG)
  298. X        chgrp kmem $(DIRINSTALL)/$(PROG)
  299. X        chmod 2755 $(DIRINSTALL)/$(PROG)
  300. Xlint:
  301. X        lint -x -b $(CFLAGS) *.c
  302. Xclean:
  303. X        rm -f $(OBJS) $(PROG)
  304. END_OF_Makefile.4.3+NFS
  305. if test 1089 -ne `wc -c <Makefile.4.3+NFS`; then
  306.     echo shar: \"Makefile.4.3+NFS\" unpacked with wrong size!
  307. fi
  308. # end of overwriting check
  309. fi
  310. if test -f Makefile.sun -a "${1}" != "-c" ; then 
  311.   echo shar: Will not over-write existing file \"Makefile.sun\"
  312. else
  313. echo shar: Extracting \"Makefile.sun\" \(988 characters\)
  314. sed "s/^X//" >Makefile.sun <<'END_OF_Makefile.sun'
  315. X# Makefile for SPS (Sun-2 and Sun-3, 4.2BSD UNIX Version)
  316. X
  317. XPROG    =       sps
  318. XOBJS    =       filecount.o findtty.o flagdecode.o flagsetup.o \
  319. X        getcmd.o getupage.o globals1.o globals2.o hashuid.o \
  320. X        initialise.o initsymbols.o inittty.o main.o mktree.o \
  321. X        needed.o openfiles.o percentmem.o prcmd.o prcpu.o \
  322. X        prheader.o printall.o printproc.o prsummary.o readstatus.o \
  323. X        selectproc.o selecttty.o termwidth.o ttystatus.o waitingfor.o
  324. XINCS    =       sps.h
  325. XCC      =       cc
  326. XCFLAGS  =       -DSUN -DBSD42 -DNFS -I/sys
  327. XLIBS    =       -ltermlib
  328. XDIRINSTALL    = /bin
  329. X
  330. Xall:            $(PROG)
  331. X.c.o:
  332. X        $(CC) $(CFLAGS) -c -O -R $<
  333. X    
  334. Xglobals1.o waitingfor.o:
  335. X        $(CC) $(CFLAGS) -c -O $<
  336. X
  337. X$(OBJS):        $(INCS)
  338. X
  339. X$(PROG):        $(OBJS)
  340. X        $(CC) -o $@ $(OBJS) $(LIBS)
  341. X
  342. Xinstall:        $(PROG)
  343. X        strip $(PROG)
  344. X        mv $(PROG) $(DIRINSTALL)/$(PROG)
  345. X        /etc/chown root $(DIRINSTALL)/$(PROG)
  346. X        chgrp kmem $(DIRINSTALL)/$(PROG)
  347. X        chmod 2755 $(DIRINSTALL)/$(PROG)
  348. X
  349. Xlint:
  350. X        lint -x -b $(CFLAGS) *.c
  351. Xclean:
  352. X        rm -f $(OBJS) $(PROG)
  353. END_OF_Makefile.sun
  354. if test 988 -ne `wc -c <Makefile.sun`; then
  355.     echo shar: \"Makefile.sun\" unpacked with wrong size!
  356. fi
  357. # end of overwriting check
  358. fi
  359. if test -f README -a "${1}" != "-c" ; then 
  360.   echo shar: Will not over-write existing file \"README\"
  361. else
  362. echo shar: Extracting \"README\" \(1226 characters\)
  363. sed "s/^X//" >README <<'END_OF_README'
  364. X        SPS - Show Process Status
  365. X        =========================
  366. XTo compile, install and test, type the following commands (as super-user):
  367. X    % make                  # Compile SPS
  368. X    % make install          # Install SPS into /bin/sps
  369. X    % sps i                 # Initialise SPS
  370. X    % sps va                # Run SPS
  371. X********************************************************************************
  372. XThe files in this directory are for the 4.[12]BSD / VAX-11 version of SPS.
  373. XCompiler options are as follows -
  374. X    -DCHAOS         if the Chaos network is incorporated into 4.xbsd
  375. X    -DTRACE         for testing/debugging purposes
  376. X    -DBSD42         compile SPS for 4.2bsd.
  377. X            Otherwise, SPS is compiled for 4.1bsd.
  378. X********************************************************************************
  379. XIf you want to tell SPS about a new type of device, then add a new line to
  380. Xthe symbol table (see globals2.c),after ensuring that there is sufficient
  381. Xroom in the `info' structure. (NWAITSTATE may need to be increased in sps.h).
  382. X********************************************************************************
  383. XSPS understands if the size of internal kernel tables are changed under VMUNIX,
  384. Xbut must be recompiled if major modifications are made to the kernel.
  385. END_OF_README
  386. if test 1226 -ne `wc -c <README`; then
  387.     echo shar: \"README\" unpacked with wrong size!
  388. fi
  389. # end of overwriting check
  390. fi
  391. if test -f README2 -a "${1}" != "-c" ; then 
  392.   echo shar: Will not over-write existing file \"README2\"
  393. else
  394. echo shar: Extracting \"README2\" \(3050 characters\)
  395. sed "s/^X//" >README2 <<'END_OF_README2'
  396. X        SPS  -  Show Process Status
  397. X        ===========================
  398. X
  399. XSPS is a intended to be used as a replacement for the standard ps(1)
  400. Xprogram. Its advantages over ps(1) are that it shows more useful
  401. Xinformation and that it is faster.
  402. X
  403. XSPS is currently implemented for 4.1 and 4.2bsd Unix on Vaxen and for
  404. XSun's 4.2bsd/Release 2. (I also have a somewhat older implementation
  405. Xfor V7 on a PDP-11 as well as Unisoft Version 1.3 on a MC68000 if you
  406. Xare interested).
  407. X
  408. XSPS displays wait channels symbolically, rather than as hexadecimal
  409. Xaddresses. If you wish to teach sps about a new sort of device, you
  410. Xmust add an entry in the symbol table (globals2.c) as well as
  411. Xincreasing the size of that table (NWAITSTATE in sps.h).
  412. X
  413. XSPS sorts processes before listing them. The order reflects the
  414. Xrelationship of the processes. A child process is listed underneath its
  415. Xcorresponding parent and is indented to depict the exact relationship.
  416. XSPS also indicates setuid processes.
  417. X
  418. XSPS displays such values as the resident and virtual sizes of system
  419. Xprocesses.  It accepts a whole range of options to control the output.
  420. XBy default, SPS lists information about one's own processes. Other
  421. Xoptions instruct it to be verbose (the "v" option), to list all the
  422. Xcommand arguments of a process (the "w" option) or to list the
  423. Xenvironment strings of that process (the "e" option). Similarly, there
  424. Xare options to control which processes are to be displayed. The "a"
  425. Xoption tells it to describe all processes and the "b" option tells it
  426. Xto describe "busy" processes, which is useful if you wish to find out
  427. Xwhat is loading your system. There are also options to select the
  428. Xoutput according to user, controlling tty or process number.
  429. X
  430. XSPS keeps its information in an information file. By default, this is
  431. X/etc/spsinfo. This means that it can avoid having to do an expensive
  432. Xnlist() operation each time it is run. It must be reinitialised (with
  433. Xthe "i" option) if new users are added to /etc/passwd or if a new
  434. Xversion of /vmunix is installed.
  435. X
  436. XTo compile SPS, unbundle the four shell archive files.  Check that the
  437. Xdefine statements in sps.h are large enough for your system (You may
  438. Xneed to alter MAXTTYS).  Then compile it using the appropriate
  439. XMakefile. Initialise it by typing "sps i" (ignore any error messages at
  440. Xthis stage) and then test it out by typing "sps va". That should make
  441. XSPS list verbose information about every process currently active. If
  442. Xthat works, use the appropriate Makefile to install it.
  443. X
  444. XSend all bug reports, fixes, comments and suggestions to Robert Ward at -
  445. X
  446. X******************************************************************************
  447. X    Robert Ward,
  448. X    Hasler AG, Murtenstrasse 137a, CH-3008 Bern, Switzerland
  449. X
  450. XTel.:        (031) - 65 23 19
  451. XUucp:        ... {seismo,decvax,ukc, ... }!mcvax!cernvax!hslrswi!robert
  452. XBitnet:        hslrswi!robert@cernvax.bitnet
  453. XArpa:        hslrswi!robert%cernvax.bitnet@WISCVM.ARPA
  454. XEdunet:        hslrswi!robert%cernvax.bitnet@UCBJADE.Berkeley.EDU
  455. X******************************************************************************
  456. END_OF_README2
  457. if test 3050 -ne `wc -c <README2`; then
  458.     echo shar: \"README2\" unpacked with wrong size!
  459. fi
  460. # end of overwriting check
  461. fi
  462. if test -f filecount.c -a "${1}" != "-c" ; then 
  463.   echo shar: Will not over-write existing file \"filecount.c\"
  464. else
  465. echo shar: Extracting \"filecount.c\" \(351 characters\)
  466. sed "s/^X//" >filecount.c <<'END_OF_filecount.c'
  467. X# include       "sps.h"
  468. X
  469. X/* FILECOUNT - Counts the # open files for the current process */
  470. Xfilecount ()
  471. X{
  472. X    register int            i ;
  473. X    register struct file    **f ;
  474. X    register int            count ;
  475. X    extern union userstate  User ;
  476. X
  477. X    count = 0 ;
  478. X    for ( i = 0, f = User.u_us.u_ofile ; i < NOFILE ; i++ )
  479. X        if ( *f++ )
  480. X            count++ ;
  481. X    return ( count ) ;
  482. X}
  483. END_OF_filecount.c
  484. if test 351 -ne `wc -c <filecount.c`; then
  485.     echo shar: \"filecount.c\" unpacked with wrong size!
  486. fi
  487. # end of overwriting check
  488. fi
  489. if test -f findtty.c -a "${1}" != "-c" ; then 
  490.   echo shar: Will not over-write existing file \"findtty.c\"
  491. else
  492. echo shar: Extracting \"findtty.c\" \(533 characters\)
  493. sed "s/^X//" >findtty.c <<'END_OF_findtty.c'
  494. X# include       "sps.h"
  495. X# include       <h/ioctl.h>
  496. X# include       <h/tty.h>
  497. X
  498. X/* FINDTTY - Attempts to determine to which tty a process is connected */
  499. Xstruct ttyline  *findtty ( p )
  500. X
  501. Xregister struct process         *p ;
  502. X
  503. X{
  504. X    register struct ttyline *lp ;
  505. X    extern struct info      Info ;
  506. X    extern struct ttyline   Notty ;
  507. X    extern union userstate  User ;
  508. X
  509. X    if ( !p->pr_p.p_pgrp )
  510. X        return ( &Notty ) ;
  511. X    for ( lp = Info.i_ttyline ; lp->l_name[0] ; lp++ )
  512. X        if ( lp->l_dev == User.u_us.u_ttyd )
  513. X            return ( lp ) ;
  514. X    return ( &Notty ) ;
  515. X}
  516. END_OF_findtty.c
  517. if test 533 -ne `wc -c <findtty.c`; then
  518.     echo shar: \"findtty.c\" unpacked with wrong size!
  519. fi
  520. # end of overwriting check
  521. fi
  522. if test -f flags.h -a "${1}" != "-c" ; then 
  523.   echo shar: Will not over-write existing file \"flags.h\"
  524. else
  525. echo shar: Extracting \"flags.h\" \(2488 characters\)
  526. sed "s/^X//" >flags.h <<'END_OF_flags.h'
  527. X/* Structure holding information specified in the option list ... */
  528. Xunion flaglist
  529. X{
  530. X    char                    *f_chp ;        /* Option specified as string */
  531. X    int                     f_uid ;         /* Numerical user id */
  532. X    int                     f_pid ;         /* Numerical process id */
  533. X    struct ttyline          *f_ttyline ;    /* Specified tty */
  534. X} ;
  535. X
  536. X/* Structure holding global information specifed by arg list options ... */
  537. Xstruct flags
  538. X{
  539. X    int                     flg_d:1 ;       /* disc orientated output */
  540. X    int                     flg_e:1 ;       /* print environment string */
  541. X    int                     flg_f:1 ;       /* print process father # */
  542. X    int                     flg_g:1 ;       /* print process group # */
  543. X    int                     flg_i:1 ;       /* initialise sps */
  544. X    char                    *flg_j ;        /* Use this as the info file */
  545. X    char                    *flg_k ;        /* Use this as the {k}mem file*/
  546. X    int                     flg_o:1 ;       /* avoid the swap device */
  547. X    int                     flg_q:1 ;       /* show user time only */
  548. X    int                     flg_r:1 ;       /* repeat output */
  549. X    unsigned                flg_rdelay ;    /* ... with this much delay */
  550. X    char                    *flg_s ;        /* Use this as the symbol file*/
  551. X    int                     flg_v:1 ;       /* print verbose listing */
  552. X    int                     flg_w:1 ;       /* print wide output */
  553. X    int                     flg_y:1 ;       /* print tty information */
  554. X    int                     flg_A:1 ;       /* print all processes */
  555. X    int                     flg_B:1 ;       /* print busy processes */
  556. X    int                     flg_F:1 ;       /* print foreground processes */
  557. X    int                     flg_N:1 ;       /* print no processes */
  558. X    int                     flg_P:1 ;       /* print specified process #'s*/
  559. X    int                     flg_S:1 ;       /* print stopped processes */
  560. X    int                     flg_T:1 ;       /* print procs for given ttys */
  561. X    int                     flg_U:1 ;       /* print procs for given users*/
  562. X    int                     flg_W:1 ;       /* print waiting processes */
  563. X    int                     flg_Z:1 ;       /* print zombie processes */
  564. X    int                     flg_AZ:1 ;      /* One of A to Z was specified*/
  565. X    union flaglist          *flg_Plist ;    /* List of specified processes*/
  566. X    union flaglist          *flg_Tlist ;    /* List of specified ttys */
  567. X    union flaglist          *flg_Ulist ;    /* List of specified users */
  568. X} ;
  569. END_OF_flags.h
  570. if test 2488 -ne `wc -c <flags.h`; then
  571.     echo shar: \"flags.h\" unpacked with wrong size!
  572. fi
  573. # end of overwriting check
  574. fi
  575. if test -f flagsetup.c -a "${1}" != "-c" ; then 
  576.   echo shar: Will not over-write existing file \"flagsetup.c\"
  577. else
  578. echo shar: Extracting \"flagsetup.c\" \(2210 characters\)
  579. sed "s/^X//" >flagsetup.c <<'END_OF_flagsetup.c'
  580. X# include       "sps.h"
  581. X# include       "flags.h"
  582. X# include       <h/ioctl.h>
  583. X# include       <h/tty.h>
  584. X
  585. X/*
  586. X** FLAGSETUP - Replaces any users or processes specified by flagdecode()
  587. X** with numerical equivalents. The lists are terminated by negative values.
  588. X** or null pointers. Ttystatus() must have been previously called to
  589. X** initialise the Info structure with chaos tty values.
  590. X*/
  591. Xflagsetup ()
  592. X{
  593. X    register union flaglist *fp ;
  594. X    register char           *chp ;
  595. X    register int            i ;
  596. X    register struct ttyline *lp ;
  597. X    int                     found ;
  598. X    extern struct flags     Flg ;
  599. X    extern struct info      Info ;
  600. X
  601. X    /* Look for specified users */
  602. X    if ( Flg.flg_U )                
  603. X    {
  604. X        if ( !Flg.flg_Ulist->f_chp )
  605. X            prexit( "sps - User name was expected after -u flag\n");
  606. X        for ( fp = Flg.flg_Ulist ; chp = fp->f_chp ; fp++ )
  607. X        {
  608. X            found = 0 ;
  609. X            for ( i = 0 ; i < MAXUSERID ; i++ )
  610. X                if ( !strncmp( chp, Info.i_hnames[i].h_uname,
  611. X                    UNAMELEN ) )
  612. X                {
  613. X                    fp->f_uid = Info.i_hnames[i].h_uid ;
  614. X                    found = 1 ;
  615. X                    break ;
  616. X                }
  617. X            if ( !found )
  618. X                prexit( "sps - Unknown user: %s\n", chp ) ;
  619. X        }
  620. X        fp->f_uid = -1 ;
  621. X    }
  622. X    /* Look for specified process ids */
  623. X    if ( Flg.flg_P )                
  624. X    {
  625. X        if ( !Flg.flg_Plist->f_chp )
  626. X            prexit(
  627. X                 "sps - Process id was expected after -p flag\n" ) ;
  628. X        for ( fp = Flg.flg_Plist ; chp = fp->f_chp ; fp++ )
  629. X        {
  630. X            if ( chp[0] < '0' || chp[0] > '9' )
  631. X                prexit( "sps - Bad process id: %s\n", chp ) ;
  632. X            fp->f_pid = atoi( chp ) ;
  633. X        }
  634. X        fp->f_pid = -1 ;
  635. X    }
  636. X    /* Look for specified ttys */
  637. X    if ( !Flg.flg_T )               
  638. X        return ;
  639. X    if ( !Flg.flg_Tlist->f_chp )
  640. X        prexit( "sps - Tty name was expected after -t flag\n" ) ;
  641. X    for ( fp = Flg.flg_Tlist ; chp = fp->f_chp ; fp++ )
  642. X    {       /* Under VMUNIX, all ttys have two character names.
  643. X           Thus, a flag of the form `t 8' should be expanded to
  644. X           become `t 08'. */
  645. X        if ( !chp[1] )
  646. X            chp[1] = chp[0], chp[0] = '0' ;
  647. X        found = 0 ;
  648. X        for ( lp = Info.i_ttyline ; lp->l_name[0] ; lp++ )
  649. X            if ( !strncmp( chp, lp->l_name, 2 ) )
  650. X            {
  651. X                fp->f_ttyline = lp ;
  652. X                found = 1 ;
  653. X                break ;
  654. X            }
  655. X        if ( !found )
  656. X            prexit( "sps - Unknown tty name: %.2s\n", chp ) ;
  657. X    }
  658. X    fp->f_ttyline = (struct ttyline*)0 ;
  659. X}
  660. END_OF_flagsetup.c
  661. if test 2210 -ne `wc -c <flagsetup.c`; then
  662.     echo shar: \"flagsetup.c\" unpacked with wrong size!
  663. fi
  664. # end of overwriting check
  665. fi
  666. if test -f getupage.c -a "${1}" != "-c" ; then 
  667.   echo shar: Will not over-write existing file \"getupage.c\"
  668. else
  669. echo shar: Extracting \"getupage.c\" \(2971 characters\)
  670. sed "s/^X//" >getupage.c <<'END_OF_getupage.c'
  671. X# include       "sps.h"
  672. X# include       <h/vm.h>
  673. X# ifdef BSD42
  674. X# include    <machine/pte.h>
  675. X# else
  676. X# include       <h/pte.h>
  677. X# endif
  678. X# include       <stdio.h>
  679. X
  680. X/*
  681. X** GETUPAGE - Reads the upage for the specified process as well as sufficient
  682. X** page tables entries for reading the command arguments. The pte's are read
  683. X** into the argument `ptetbl'. The upage is read into the external variable
  684. X** `User'. This procedure returns 1 if the upage was successfully read.
  685. X*/
  686. X
  687. X# define        usrpt           (Info.i_usrpt)
  688. X
  689. Xgetupage ( p, ptetbl )
  690. X
  691. Xregister struct process         *p ;
  692. Xregister struct pte             *ptetbl ;
  693. X
  694. X{
  695. X    register int            i ;
  696. X    register int            ncl ;
  697. X    struct pte              pte ;
  698. X    extern struct info      Info ;
  699. X    extern union userstate  User ;
  700. X    extern int              Flmem, Flkmem, Flswap ;
  701. X
  702. X    /* If the process is not loaded, look for the upage on the swap device*/
  703. X    if ( !(p->pr_p.p_flag & SLOAD) )
  704. X    {                               
  705. X# ifdef BSD42
  706. X        swseek( (long)dtob( p->pr_p.p_swaddr ) ) ;
  707. X# else
  708. X        swseek( (long)ctob( p->pr_p.p_swaddr ) ) ;
  709. X# endif
  710. X# ifdef SUN
  711. X        if ( read( Flswap, (char*)&User.u_us, sizeof( union userstate ))
  712. X        != sizeof( union userstate ) )
  713. X# else
  714. X        if ( read( Flswap, (char*)&User.u_us, sizeof( struct user ) )
  715. X        != sizeof( struct user ) )
  716. X# endif
  717. X        {
  718. X            fprintf( stderr,
  719. X                "sps - Can't read upage of process %d\n",
  720. X                p->pr_p.p_pid ) ;
  721. X            return ( 0 ) ;
  722. X        }
  723. X        return ( 1 ) ;          
  724. X    }                               
  725. X    /* The process is loaded. Locate the process pte's by reading
  726. X       the pte of their base address from system virtual address space. */
  727. X    memseek( Flkmem, (long)&Info.i_usrptmap[ btokmx(p->pr_p.p_p0br)
  728. X        + p->pr_p.p_szpt-1 ] ) ;
  729. X    if ( read( Flkmem, (char*)&pte, sizeof( struct pte ) )
  730. X    != sizeof( struct pte ) )
  731. X    {
  732. X        fprintf( stderr,
  733. X              "sps - Can't read indir pte for upage of process %d\n",
  734. X            p->pr_p.p_pid ) ;
  735. X        return ( 0 ) ;
  736. X    }                               
  737. X    /* Now read the process' pte's from physical memory. We need to access
  738. X       sufficient pte's for the upage and for the command arguments. */
  739. X    memseek( Flmem, (long)ctob( pte.pg_pfnum+1 )
  740. X        - (UPAGES+CLSIZE)*sizeof( struct pte ) ) ;
  741. X    if ( read( Flmem, (char*)ptetbl, (UPAGES+CLSIZE)*sizeof( struct pte ) )
  742. X    != (UPAGES+CLSIZE)*sizeof( struct pte ) )
  743. X    {
  744. X        fprintf( stderr, "sps - Can't read page table of process %d\n",
  745. X            p->pr_p.p_pid ) ;
  746. X        return ( 0 ) ;
  747. X    }
  748. X    /* Now we can read the pages belonging to the upage.
  749. X       Here we read in an entire click at one go. */
  750. X    ncl = (sizeof( struct user ) + NBPG*CLSIZE - 1) / (NBPG*CLSIZE) ;
  751. X    while ( --ncl >= 0 )            
  752. X    {                               
  753. X        i = ncl * CLSIZE ;
  754. X        memseek( Flmem, (long)ctob( ptetbl[ CLSIZE+i ].pg_pfnum ) ) ;
  755. X        if ( read( Flmem, User.u_pg[i], CLSIZE*NBPG ) != CLSIZE*NBPG )
  756. X        {
  757. X            fprintf( stderr,
  758. X                "sps - Can't read page 0x%x of process %d\n",
  759. X                ptetbl[ CLSIZE+i ].pg_pfnum, p->pr_p.p_pid ) ;
  760. X            return ( 0 ) ;
  761. X        }
  762. X    }
  763. X    return ( 1 ) ;
  764. X}
  765. END_OF_getupage.c
  766. if test 2971 -ne `wc -c <getupage.c`; then
  767.     echo shar: \"getupage.c\" unpacked with wrong size!
  768. fi
  769. # end of overwriting check
  770. fi
  771. if test -f globals1.c -a "${1}" != "-c" ; then 
  772.   echo shar: Will not over-write existing file \"globals1.c\"
  773. else
  774. echo shar: Extracting \"globals1.c\" \(720 characters\)
  775. sed "s/^X//" >globals1.c <<'END_OF_globals1.c'
  776. X# include       "sps.h"
  777. X# include       "flags.h"
  778. X
  779. X/* Read/Write Variables global to the code of sps */
  780. X
  781. Xstruct info                     Info ;          /* Information structure */
  782. X
  783. Xstruct flags                    Flg ;           /* Flag options */
  784. X
  785. Xstruct summary                  Summary ;       /* Summary of processes */
  786. X
  787. Xunion  userstate                User ;          /* Upage of one process */
  788. X
  789. Xint                             Flmem, Flkmem, Flswap ; /* File descriptors */
  790. X
  791. Xunsigned                        Termwidth ;     /* Width of output device */
  792. X
  793. Xshort                           Lastpgrp ;      /* Last process pgrp printed */
  794. X
  795. Xshort                           Lastuid ;       /* Last process uid printed */
  796. END_OF_globals1.c
  797. if test 720 -ne `wc -c <globals1.c`; then
  798.     echo shar: \"globals1.c\" unpacked with wrong size!
  799. fi
  800. # end of overwriting check
  801. fi
  802. if test -f hashuid.c -a "${1}" != "-c" ; then 
  803.   echo shar: Will not over-write existing file \"hashuid.c\"
  804. else
  805. echo shar: Extracting \"hashuid.c\" \(1441 characters\)
  806. sed "s/^X//" >hashuid.c <<'END_OF_hashuid.c'
  807. X# include       "sps.h"
  808. X
  809. X/* The hashing functions themselves ... */
  810. X# define        HASHFN1( a )            (((unsigned)(a)*91 + 17) % MAXUSERID)
  811. X# define        HASHFN2( a )            (((unsigned)(a) + 47) % MAXUSERID)
  812. X
  813. X/*
  814. X** HASHUID - Returns a pointer to a slot in the hash table that corresponds
  815. X** to the hash table entry for `uid'. It returns a null pointer if there is
  816. X** no such slot.
  817. X*/
  818. Xstruct hashtab  *hashuid ( uid )
  819. X
  820. Xint                             uid ;
  821. X
  822. X{
  823. X    register struct hashtab *hp ;
  824. X    register int            i ;
  825. X    register int            j ;
  826. X    extern struct info      Info ;
  827. X
  828. X    j = HASHFN1( uid ) ;
  829. X    for ( i = 0 ; i < MAXUSERID ; i++ )
  830. X    {
  831. X        hp = &Info.i_hnames[ j ] ;
  832. X        if ( !hp->h_uname[0] )
  833. X            return ( (struct hashtab*)0 ) ;
  834. X        if ( hp->h_uid == uid )
  835. X            return ( hp ) ;
  836. X        j = HASHFN2( j ) ;
  837. X    }
  838. X    return ( (struct hashtab*)0 ) ;
  839. X}
  840. X
  841. X/*
  842. X** HASHNEXT - Returns a pointer to the next slot in the hash table that
  843. X** may be use for storing information for `uid'. It returns a null pointer
  844. X** if there are no more free slots available.
  845. X*/
  846. Xstruct hashtab  *hashnext ( uid )
  847. X
  848. Xint                             uid ;
  849. X
  850. X{
  851. X    register struct hashtab *hp ;
  852. X    register int            i ;
  853. X    register int            j ;
  854. X    extern struct info      Info ;
  855. X
  856. X    j = HASHFN1( uid ) ;
  857. X    for ( i = 0 ; i < MAXUSERID ; i++ )
  858. X    {
  859. X        hp = &Info.i_hnames[ j ] ;
  860. X        if ( !hp->h_uname[0] )
  861. X            return ( hp ) ;
  862. X        j = HASHFN2( j ) ;
  863. X    }
  864. X    return ( (struct hashtab*)0 ) ;
  865. X}
  866. END_OF_hashuid.c
  867. if test 1441 -ne `wc -c <hashuid.c`; then
  868.     echo shar: \"hashuid.c\" unpacked with wrong size!
  869. fi
  870. # end of overwriting check
  871. fi
  872. if test -f initialise.c -a "${1}" != "-c" ; then 
  873.   echo shar: Will not over-write existing file \"initialise.c\"
  874. else
  875. echo shar: Extracting \"initialise.c\" \(1905 characters\)
  876. sed "s/^X//" >initialise.c <<'END_OF_initialise.c'
  877. X# include       "sps.h"
  878. X# include       "flags.h"
  879. X# include       <pwd.h>
  880. X# include       <stdio.h>
  881. X
  882. X/*
  883. X** INITIALISE - Called to reset the `Info' structure with new kernel
  884. X** addresses and user and tty information.
  885. X*/
  886. Xinitialise ()
  887. X{
  888. X    register FILE           *fd ;
  889. X    char                    *fileinfo ;
  890. X    extern struct flags     Flg ;
  891. X    extern struct info      Info ;
  892. X    FILE                    *fopen() ;
  893. X
  894. X    fileinfo = Flg.flg_j ? Flg.flg_j : FILE_INFO ;
  895. X    /* Read kernel addresses */
  896. X    initsymbols() ;                 
  897. X    /* Read user names */
  898. X    initusers() ;                   
  899. X    (void)umask( ~0644 ) ;          
  900. X    if ( !(fd = fopen( fileinfo, "w" )) )
  901. X    {
  902. X        fprintf( stderr, "sps - Can't create info file %s", fileinfo ) ;
  903. X        sysperror() ;
  904. X    }
  905. X    /* Find tty addresses */
  906. X    inittty() ;                     
  907. X    if ( fwrite( (char*)&Info, sizeof( struct info ), 1, fd ) != 1 )
  908. X    {
  909. X        fprintf( stderr, "sps - Can't write info file %s", fileinfo ) ;
  910. X        sysperror() ;
  911. X        exit( 1 ) ;
  912. X    }
  913. X    (void)fclose( fd ) ;
  914. X    printf( "sps is initialised\n" ) ;
  915. X}
  916. X
  917. X/* INITUSERS - Read the passwd file and fill in the user name arrays */
  918. Xinitusers ()
  919. X{
  920. X    register struct passwd  *pw ;
  921. X    register struct hashtab *hp ;
  922. X    struct passwd           *getpwent() ;
  923. X    char                    *strncpy() ;
  924. X    struct hashtab          *hashuid(), *hashnext() ;
  925. X
  926. X    while ( pw = getpwent() )
  927. X    {       /* For each user in the passwd file, first see if that uid
  928. X           has been already allocated in the hash table. */
  929. X        if ( hp = hashuid( pw->pw_uid ) )
  930. X        {
  931. X            fprintf( stderr,
  932. X           "sps - Names %s and %s conflict in passwd file for uid %d\n",
  933. X                hp->h_uname, pw->pw_name, pw->pw_uid ) ;
  934. X            continue ;
  935. X        }
  936. X        /* Try to find a free slot in the hash table and fill it. */
  937. X        if ( !(hp = hashnext( pw->pw_uid )) )
  938. X            prexit( "sps - Too many users in passwd file\n" ) ;
  939. X        hp->h_uid = pw->pw_uid ;
  940. X        (void)strncpy( hp->h_uname, pw->pw_name, UNAMELEN ) ;
  941. X    }
  942. X    (void)endpwent() ;
  943. X}
  944. END_OF_initialise.c
  945. if test 1905 -ne `wc -c <initialise.c`; then
  946.     echo shar: \"initialise.c\" unpacked with wrong size!
  947. fi
  948. # end of overwriting check
  949. fi
  950. if test -f initsymbols.c -a "${1}" != "-c" ; then 
  951.   echo shar: Will not over-write existing file \"initsymbols.c\"
  952. else
  953. echo shar: Extracting \"initsymbols.c\" \(3000 characters\)
  954. sed "s/^X//" >initsymbols.c <<'END_OF_initsymbols.c'
  955. X# include       "sps.h"
  956. X# include       "flags.h"
  957. X# ifdef BSD42
  958. X# include       <sys/file.h>
  959. X# endif
  960. X# include       <nlist.h>
  961. X# include       <stdio.h>
  962. X
  963. X/* INITSYMBOLS - Reads kmem values into the Info structure */
  964. X/*
  965. X** THIS CODE COPIES KMEM VALUES INTO THE INFO STRUCTURE ASSUMING THAT
  966. X** VALUES READ FROM THE KERNEL HAVE TYPE CADDR_T. THEREFORE, WE ARE
  967. X** MAKING THE DUBIOUS ASSUMPTION THAT INTS, POINTERS AND CADDR_T's
  968. X** HAVE IDENTICAL SIZES.
  969. X*/
  970. Xinitsymbols ()
  971. X{
  972. X    register struct nlist   *np ;
  973. X    register struct symbol  *s ;
  974. X    register struct nlist   *np0 ;
  975. X    char                    *filesymbol ;
  976. X    extern int              Flkmem ;
  977. X    extern struct flags     Flg ;
  978. X    extern struct symbol    Symbollist[] ;
  979. X    extern struct info      Info ;
  980. X    char                    *getcore() ;
  981. X    char                    *strncpy() ;
  982. X
  983. X    filesymbol = Flg.flg_s ? Flg.flg_s : FILE_SYMBOL ;
  984. X    /* Find the length of the symbol table */
  985. X    for ( s = Symbollist ; s->s_kname ; s++ )
  986. X        ;
  987. X    /* Construct an nlist structure by copying names from the symbol table*/
  988. X    np0 = (struct nlist*)getcore( (s-Symbollist+1)*sizeof( struct nlist ) );
  989. X    for ( s = Symbollist, np = np0 ; s->s_kname ; s++, np++ )
  990. X    {                                       
  991. X        np->n_name = s->s_kname ;       
  992. X        np[1].n_name = (char*)0 ;       
  993. X        np->n_value = 0 ;
  994. X    }
  995. X# ifdef BSD42
  996. X    if ( access( filesymbol, R_OK ) < 0 )
  997. X# else
  998. X    if ( access( filesymbol, 4 ) < 0 )
  999. X# endif
  1000. X    {
  1001. X        fprintf( stderr, "sps - Can't open symbol file %s", filesymbol);
  1002. X        sysperror() ;
  1003. X    }
  1004. X    /* Get kernel addresses */
  1005. X    (void)nlist( filesymbol, np0 ) ;              
  1006. X    if ( np0[0].n_value == -1 )
  1007. X    {
  1008. X        fprintf( stderr, "sps - Can't read symbol file %s", filesymbol);
  1009. X        sysperror() ;
  1010. X    }
  1011. X    for ( s = Symbollist, np = np0 ; s->s_kname ; s++, np++ )
  1012. X    {                                       
  1013. X        if ( !np->n_value )             
  1014. X        {
  1015. X            fprintf( stderr, "sps - Can't find symbol %s in %s",
  1016. X                np->n_name, filesymbol ) ;
  1017. X            /* Assume this error to be unimportant if the address
  1018. X               is only associated with a process wait state.
  1019. X               This may happen if the system has been configured
  1020. X               without a particular device. */
  1021. X            fprintf( stderr, &Info.i_waitstate[ 0 ] <= s->s_info
  1022. X                && s->s_info < &Info.i_waitstate[ NWAITSTATE ]
  1023. X                ? " (error is not serious)\n"
  1024. X                : " (ERROR MAY BE SERIOUS)\n" ) ;
  1025. X            *s->s_info = (caddr_t)0 ;
  1026. X            continue ;
  1027. X        }
  1028. X        /* If no indirection is required, just copy the obtained value
  1029. X           into the `Info' structure. */
  1030. X        if ( !s->s_indirect )           
  1031. X        {                               
  1032. X        /* DUBIOUS ASSUMPTION THAT KMEM VALUE HAS SIZE OF A CADDR_T */
  1033. X            *s->s_info = (caddr_t)np->n_value ;
  1034. X            continue ;              
  1035. X        }                               
  1036. X        /* Otherwise one level of indirection is required. Using the
  1037. X           obtained address, look again in the kernel for the value */
  1038. X        memseek( Flkmem, (long)np->n_value ) ;
  1039. X        /* DUBIOUS ASSUMPTION THAT KMEM VALUE HAS SIZE OF A CADDR_T */
  1040. X        (void)read( Flkmem, (char*)s->s_info, sizeof(caddr_t) ) ;
  1041. X    }
  1042. X    free( (char*)np0 ) ;
  1043. X}
  1044. END_OF_initsymbols.c
  1045. if test 3000 -ne `wc -c <initsymbols.c`; then
  1046.     echo shar: \"initsymbols.c\" unpacked with wrong size!
  1047. fi
  1048. # end of overwriting check
  1049. fi
  1050. if test -f main.c -a "${1}" != "-c" ; then 
  1051.   echo shar: Will not over-write existing file \"main.c\"
  1052. else
  1053. echo shar: Extracting \"main.c\" \(3406 characters\)
  1054. sed "s/^X//" >main.c <<'END_OF_main.c'
  1055. X# include       "sps.h"
  1056. X# include       "flags.h"
  1057. X# include       <h/text.h>
  1058. X# include       <sys/stat.h>
  1059. X# include       <stdio.h>
  1060. X
  1061. X
  1062. X/* SPS - Show Process Status */
  1063. X/* J. R. Ward - Hasler AG Bern, CH - 24 May 1985 */
  1064. X/*                     26 Nov 1986 */
  1065. X
  1066. X/* <robert@hslrswi.uucp> */
  1067. X
  1068. Xmain ( argc,argv )
  1069. X
  1070. Xint                             argc ;
  1071. Xchar                            **argv ;
  1072. X
  1073. X{
  1074. X    register struct process *plist ;
  1075. X    register struct process *process ;
  1076. X    register struct text    *text ;
  1077. X    int                     flinfo ;
  1078. X    char            *fileinfo, *filesymbol ;
  1079. X    struct stat        sinfo, ssymbol, spasswd ;
  1080. X    extern struct flags     Flg ;
  1081. X    extern struct info      Info ;
  1082. X    extern int              Flmem ;
  1083. X    extern int              Flkmem ;
  1084. X    extern int              Flswap ;
  1085. X    char                    *getcore() ;
  1086. X    struct process          *needed(), *mktree() ;
  1087. X
  1088. X    /* Renice as fast as possible for root only (Suggested by Jeff Mogul,
  1089. X       gregorio!mogul) */
  1090. X    if ( !getuid() )
  1091. X        (void)nice( -40 ) ;
  1092. X    /* Decode the flag arguments */
  1093. X    flagdecode( argc, argv ) ;      
  1094. X    /* Determine the terminal width */
  1095. X    if ( !Flg.flg_w && !Flg.flg_N && !Flg.flg_i )
  1096. X        termwidth() ;
  1097. X    /* Open the cpu physical memory, kernel virtual memory and swap device*/
  1098. X    if ( Flg.flg_k )
  1099. X    {
  1100. X        Flmem = openfile( Flg.flg_k ) ;
  1101. X        Flkmem = Flmem ;
  1102. X    }
  1103. X    else
  1104. X    {
  1105. X        Flmem = openfile( FILE_MEM ) ;
  1106. X        Flkmem = openfile( FILE_KMEM ) ;
  1107. X        if ( !Flg.flg_o )
  1108. X            Flswap = openfile( FILE_SWAP ) ;
  1109. X    }
  1110. X    if ( Flg.flg_i )
  1111. X    {       /* -i flag for info file initialisation */
  1112. X        initialise() ;          
  1113. X        exit( 0 ) ;
  1114. X    }
  1115. X    /* Check that the information file is newer than the symbol and
  1116. X       password files, suggested by gregorio!mogul */
  1117. X    fileinfo = Flg.flg_j ? Flg.flg_j : FILE_INFO ;
  1118. X    filesymbol = Flg.flg_s ? Flg.flg_s : FILE_SYMBOL ;
  1119. X    flinfo = openfile( fileinfo ) ;
  1120. X    (void)fstat( flinfo, &sinfo ) ;
  1121. X    if ( !stat( filesymbol, &ssymbol ) &&
  1122. X        sinfo.st_mtime < ssymbol.st_mtime )
  1123. X        fprintf( stderr,
  1124. X           "sps - WARNING: Info file `%s' is older than symbol file `%s'\n",
  1125. X            fileinfo, filesymbol ) ;
  1126. X    if ( !stat( FILE_PASSWD, &spasswd ) &&
  1127. X        sinfo.st_mtime < spasswd.st_mtime )
  1128. X        fprintf( stderr,
  1129. X           "sps - WARNING: Info file `%s' is older than passwd file `%s'\n",
  1130. X            fileinfo, FILE_PASSWD ) ;
  1131. X    /* Read the information file */
  1132. X    if ( read( flinfo, (char*)&Info, sizeof( struct info ) )
  1133. X    != sizeof( struct info ) )
  1134. X    {
  1135. X        fprintf( stderr, "sps - Can't read info file `%s'", fileinfo ) ;
  1136. X        sysperror() ;
  1137. X    }
  1138. X    (void)close( flinfo ) ;
  1139. X    /* Find current tty status */
  1140. X    ttystatus() ;                   
  1141. X    /* Now that we know the available ttys, decode the flags */
  1142. X    flagsetup() ;                   
  1143. X    process = (struct process*)getcore(Info.i_nproc*sizeof(struct process));
  1144. X    text = (struct text*)getcore( Info.i_ntext * sizeof( struct text ) ) ;
  1145. X    do
  1146. X    {       /* Read current process and text status */
  1147. X        readstatus( process, text ) ;
  1148. X        /* Select those processes to be listed */
  1149. X        plist = needed( process, text ) ;
  1150. X        /* Form a tree of listed processes */
  1151. X        plist = mktree( process, plist ) ;
  1152. X        if ( !Flg.flg_N )
  1153. X        {       /* Print the processes */
  1154. X            prheader() ;
  1155. X            printall( plist, 0 ) ;
  1156. X        }
  1157. X        prsummary() ;
  1158. X        (void)fflush( stdout ) ;
  1159. X        if ( Flg.flg_r )        
  1160. X        {       /* If repeating, again get tty status */
  1161. X            ttystatus() ;
  1162. X            if ( Flg.flg_rdelay )
  1163. X# ifdef BSD42
  1164. X                sleep( Flg.flg_rdelay ) ;
  1165. X# else
  1166. X                sleep( (int)Flg.flg_rdelay ) ;
  1167. X# endif
  1168. X        }
  1169. X    } while ( Flg.flg_r ) ;
  1170. X    exit( 0 ) ;
  1171. X}
  1172. END_OF_main.c
  1173. if test 3406 -ne `wc -c <main.c`; then
  1174.     echo shar: \"main.c\" unpacked with wrong size!
  1175. fi
  1176. # end of overwriting check
  1177. fi
  1178. if test -f mktree.c -a "${1}" != "-c" ; then 
  1179.   echo shar: Will not over-write existing file \"mktree.c\"
  1180. else
  1181. echo shar: Extracting \"mktree.c\" \(1626 characters\)
  1182. sed "s/^X//" >mktree.c <<'END_OF_mktree.c'
  1183. X# include       "sps.h"
  1184. X
  1185. X/*
  1186. X** MKTREE - Sort the needed processes by subtree and at the top by user.
  1187. X** This procedure takes a list of processes (as returned by needed())
  1188. X** and returnes a pointer to a sorted list.
  1189. X*/
  1190. Xstruct process  *mktree ( process, plist )
  1191. X
  1192. Xstruct process                  *process ;
  1193. Xstruct process                  *plist ;
  1194. X
  1195. X{
  1196. X    register struct process *p ;
  1197. X    register struct process *pp ;
  1198. X    register struct process *lp ;
  1199. X    struct process          *op ;
  1200. X    struct process          proot ;
  1201. X
  1202. X    proot.pr_sibling = (struct process*)0 ;
  1203. X    for ( p = plist ; p ; p = p->pr_plink )
  1204. X    {
  1205. X        if ( p->pr_pptr > &process[1] )
  1206. X        {
  1207. X            for ( pp = plist ; pp ; pp = pp->pr_plink )
  1208. X            {
  1209. X                if ( pp != p->pr_pptr )
  1210. X                    continue ;
  1211. X                if ( lp = pp->pr_child )
  1212. X                {       /* Does process have children ? */
  1213. X                    op = (struct process*)0 ;
  1214. X                    while (lp &&
  1215. X                    lp->pr_p.p_pid < p->pr_p.p_pid )
  1216. X                    {
  1217. X                        op = lp ;
  1218. X                        lp=lp->pr_sibling ;
  1219. X                    }
  1220. X                    if ( op )
  1221. X                    {
  1222. X                        p->pr_sibling = lp ;
  1223. X                        op->pr_sibling = p ;
  1224. X                        break ;
  1225. X                    }
  1226. X                }       
  1227. X                p->pr_sibling = lp ;
  1228. X                pp->pr_child = p ;
  1229. X                break ;
  1230. X            }
  1231. X            if ( pp )
  1232. X                continue ;
  1233. X        }
  1234. X        /* We have a top level process, sort into top level list.
  1235. X           The top level is sorted firstly by user-id and then
  1236. X           by process-id. */
  1237. X        lp = &proot ;
  1238. X        pp = lp->pr_sibling ;
  1239. X        while ( pp )
  1240. X        {
  1241. X            if ( p->pr_p.p_uid < pp->pr_p.p_uid )
  1242. X                break ;
  1243. X            if ( p->pr_p.p_uid == pp->pr_p.p_uid
  1244. X            && p->pr_p.p_pid < pp->pr_p.p_pid )
  1245. X                break ;
  1246. X            lp = pp, pp = pp->pr_sibling ;
  1247. X        }
  1248. X        p->pr_sibling = lp->pr_sibling ;
  1249. X        lp->pr_sibling = p ;
  1250. X    }
  1251. X    return ( proot.pr_sibling ) ;
  1252. X}
  1253. END_OF_mktree.c
  1254. if test 1626 -ne `wc -c <mktree.c`; then
  1255.     echo shar: \"mktree.c\" unpacked with wrong size!
  1256. fi
  1257. # end of overwriting check
  1258. fi
  1259. if test -f openfiles.c -a "${1}" != "-c" ; then 
  1260.   echo shar: Will not over-write existing file \"openfiles.c\"
  1261. else
  1262. echo shar: Extracting \"openfiles.c\" \(2626 characters\)
  1263. sed "s/^X//" >openfiles.c <<'END_OF_openfiles.c'
  1264. X# include       <stdio.h>
  1265. X# include       "sps.h"
  1266. X# include       "flags.h"
  1267. X
  1268. X/* Miscellaneous procedures */
  1269. X
  1270. X/* OPENFILE - Opens the named file */
  1271. Xopenfile ( name )
  1272. X
  1273. Xchar                            *name ;
  1274. X
  1275. X{
  1276. X    register int            fd ;
  1277. X
  1278. X    if ( (fd = open( name, 0 )) >= 0 )
  1279. X        return ( fd ) ;
  1280. X    fprintf( stderr, "sps - Can't open %s", name ) ;
  1281. X    sysperror() ;
  1282. X    /* NOTREACHED */
  1283. X}
  1284. X
  1285. X/* MEMSEEK - Seek on a special file */
  1286. Xmemseek ( fd, pos )
  1287. X
  1288. Xint                             fd ;
  1289. Xlong                            pos ;
  1290. X
  1291. X{
  1292. X    extern int              errno ;
  1293. X    extern struct flags     Flg ;
  1294. X    long                    lseek() ;
  1295. X
  1296. X    errno = 0 ;
  1297. X    if ( Flg.flg_k )
  1298. X        pos &= 0x7fffffff ;
  1299. X    (void)lseek( fd, pos, 0 ) ;
  1300. X    if ( errno )
  1301. X    {
  1302. X        fprintf( stderr, "sps - Seek failed" ) ;
  1303. X        sysperror() ;
  1304. X    }
  1305. X}
  1306. X
  1307. X/* SWSEEK - Seek on the swap device */
  1308. Xswseek ( pos )
  1309. X
  1310. Xlong                            pos ;
  1311. X
  1312. X{
  1313. X    extern int              Flswap ;
  1314. X    extern int              errno ;
  1315. X    long                    lseek() ;
  1316. X
  1317. X    errno = 0 ;
  1318. X    (void)lseek( Flswap, pos, 0 ) ;
  1319. X    if ( errno )
  1320. X    {
  1321. X        fprintf( stderr, "sps - Seek failed" ) ;
  1322. X        sysperror() ;
  1323. X    }
  1324. X}
  1325. X
  1326. X# ifdef lint
  1327. Xint                             errno ;
  1328. Xint                             sys_nerr ;
  1329. Xchar                            *sys_errlist[] ;
  1330. X# endif
  1331. X
  1332. X/* SYSPERROR - Reports a system defined error msg and then exits gracefully */
  1333. Xsysperror ()
  1334. X{
  1335. X    extern int              errno ;
  1336. X    extern int              sys_nerr ;
  1337. X    extern char             *sys_errlist[] ;
  1338. X
  1339. X    if ( 0 < errno && errno < sys_nerr )
  1340. X        fprintf( stderr, " : %s", sys_errlist[errno] ) ;
  1341. X    (void)fputc( '\n', stderr ) ;
  1342. X    exit( 1 ) ;
  1343. X}
  1344. X
  1345. X/* STRSAVE - Store a string in core for later use. */
  1346. Xchar    *strsave ( cp )
  1347. X
  1348. Xregister char                   *cp ;
  1349. X
  1350. X{
  1351. X    register char           *chp ;
  1352. X    char                    *getcore(), *strcpy() ;
  1353. X
  1354. X    chp = getcore( strlen( cp ) + 1 ) ;
  1355. X    (void)strcpy( chp, cp ) ;
  1356. X    return ( chp ) ;
  1357. X}
  1358. X
  1359. X/* GETCORE - Allocate and return a pointer to the asked for amount of core */
  1360. Xchar    *getcore ( size )
  1361. X
  1362. Xregister int                    size ;
  1363. X
  1364. X{
  1365. X    register char           *chp ;
  1366. X    char                    *malloc() ;
  1367. X
  1368. X    if ( chp = malloc( (unsigned)size ) )
  1369. X        return ( chp ) ;
  1370. X    fprintf( stderr, "sps - Out of core" ) ;
  1371. X    sysperror() ;
  1372. X    /* NOTREACHED */
  1373. X}
  1374. X
  1375. Xunion flaglist  *getflgsp ( argc )
  1376. X
  1377. Xregister int                    argc ;
  1378. X
  1379. X{
  1380. X    char                    *getcore() ;
  1381. X
  1382. X    return ( (union flaglist*)getcore( sizeof( union flaglist )*argc ) ) ;
  1383. X}
  1384. X
  1385. X/* PREXIT - Print an error message and exit */
  1386. X/* VARARGS1 */
  1387. X/* ARGSUSED */
  1388. Xprexit ( fmt, args )
  1389. X
  1390. Xchar                            *fmt ;
  1391. X
  1392. X{
  1393. X    _doprnt( fmt, &args, stderr ) ;
  1394. X    exit( 1 ) ;
  1395. X}
  1396. END_OF_openfiles.c
  1397. if test 2626 -ne `wc -c <openfiles.c`; then
  1398.     echo shar: \"openfiles.c\" unpacked with wrong size!
  1399. fi
  1400. # end of overwriting check
  1401. fi
  1402. if test -f percentmem.c -a "${1}" != "-c" ; then 
  1403.   echo shar: Will not over-write existing file \"percentmem.c\"
  1404. else
  1405. echo shar: Extracting \"percentmem.c\" \(823 characters\)
  1406. sed "s/^X//" >percentmem.c <<'END_OF_percentmem.c'
  1407. X# include       "sps.h"
  1408. X# include       <h/text.h>
  1409. X# ifdef BSD42
  1410. X# include    <machine/pte.h>
  1411. X# else
  1412. X# include       <h/pte.h>
  1413. X# include       <h/vmparam.h>
  1414. X# endif
  1415. X# include       <h/vmmac.h>
  1416. X
  1417. X/* PERCENTMEM - Returns the percentage of real memory used by this process */
  1418. Xdouble  percentmem ( p )
  1419. X
  1420. Xregister struct process         *p ;
  1421. X
  1422. X{
  1423. X    register struct text    *tp ;
  1424. X    int                     szptudot ;
  1425. X    double                  fracmem ;
  1426. X    extern struct info      Info ;
  1427. X
  1428. X    tp = p->pr_p.p_textp ;
  1429. X    if ( !(p->pr_p.p_flag & SLOAD) || !tp )
  1430. X        return ( 0.0 ) ;
  1431. X    szptudot = UPAGES + clrnd( ctopt( p->pr_p.p_dsize + p->pr_p.p_ssize ) );
  1432. X    fracmem = ( (double)p->pr_p.p_rssize + szptudot ) / CLSIZE ;
  1433. X    if ( tp->x_ccount )
  1434. X        fracmem += ((double)tp->x_rssize)/CLSIZE/tp->x_ccount ;
  1435. X    return ( 100.0 * fracmem / (double)Info.i_ecmx ) ;
  1436. X}
  1437. END_OF_percentmem.c
  1438. if test 823 -ne `wc -c <percentmem.c`; then
  1439.     echo shar: \"percentmem.c\" unpacked with wrong size!
  1440. fi
  1441. # end of overwriting check
  1442. fi
  1443. if test -f prcmd.c -a "${1}" != "-c" ; then 
  1444.   echo shar: Will not over-write existing file \"prcmd.c\"
  1445. else
  1446. echo shar: Extracting \"prcmd.c\" \(709 characters\)
  1447. sed "s/^X//" >prcmd.c <<'END_OF_prcmd.c'
  1448. X# include       "sps.h"
  1449. X# include       "flags.h"
  1450. X
  1451. X/* PRCMD - Prints the command arguments according to the switches */
  1452. Xprcmd ( p, lpad, width )
  1453. X
  1454. Xregister struct process         *p ;
  1455. Xint                             lpad ;
  1456. Xint                             width ;
  1457. X
  1458. X{
  1459. X    extern struct flags     Flg ;
  1460. X    extern unsigned         Termwidth ;
  1461. X
  1462. X    printf( "%*d ", lpad, p->pr_p.p_pid ) ;
  1463. X    if ( Flg.flg_f )
  1464. X    {
  1465. X        printf( "%5d ", p->pr_p.p_ppid ) ;
  1466. X        width -= 6 ;
  1467. X    }
  1468. X    if ( Flg.flg_g )
  1469. X    {
  1470. X        printf( "%5d ", p->pr_p.p_pgrp ) ;
  1471. X        width -= 6 ;
  1472. X    }
  1473. X    width += Termwidth ;
  1474. X    if ( Flg.flg_w )
  1475. X        printf( "%s\n", p->pr_cmd ) ;
  1476. X    else if ( width > 0 )
  1477. X        printf( "%-.*s\n", width, p->pr_cmd ) ;
  1478. X    if ( p->pr_csaved )
  1479. X        free( p->pr_cmd ) ;
  1480. X}
  1481. END_OF_prcmd.c
  1482. if test 709 -ne `wc -c <prcmd.c`; then
  1483.     echo shar: \"prcmd.c\" unpacked with wrong size!
  1484. fi
  1485. # end of overwriting check
  1486. fi
  1487. if test -f prcpu.c -a "${1}" != "-c" ; then 
  1488.   echo shar: Will not over-write existing file \"prcpu.c\"
  1489. else
  1490. echo shar: Extracting \"prcpu.c\" \(1538 characters\)
  1491. sed "s/^X//" >prcpu.c <<'END_OF_prcpu.c'
  1492. X# include       "sps.h"
  1493. X
  1494. X# ifdef BSD42
  1495. X
  1496. X/* PRCPU - Print cpu time */
  1497. Xprcpu ( time, utime )
  1498. X
  1499. Xregister time_t                 time ;
  1500. Xtime_t                          utime ;
  1501. X
  1502. X{
  1503. X    time += utime / 1000000 ;
  1504. X    utime %= 1000000 ;
  1505. X    if ( time < 0L )
  1506. X    {       /* Ignore negative times */
  1507. X        printf( "     " ) ;     
  1508. X        return ;
  1509. X    }
  1510. X    if ( time < 60L*10L )
  1511. X    {       /* Print as seconds if less than 1000 seconds */
  1512. X        printf( "%3d.%1d", (int)time, (int)utime/100000 ) ;
  1513. X        return ;
  1514. X    }
  1515. X    /* Print as minutes if less than 10 hours ; print as hours if less than
  1516. X       10 days, else print as days. */
  1517. X    if ( time < 60L*60L*10L )               
  1518. X        printf( "%3D M", time/60L ) ;
  1519. X    else if ( time < 24L*60L*60L*10L )
  1520. X        printf( "%3D H", time/60L/60L ) ;
  1521. X    else
  1522. X        printf( "%3D D", time/60L/60L/24L ) ;
  1523. X}
  1524. X
  1525. X# else
  1526. X
  1527. X/* PRCPU - Print cpu time */
  1528. Xprcpu ( time )
  1529. X
  1530. Xregister time_t                 time ;
  1531. X
  1532. X{
  1533. X    extern struct info      Info ;
  1534. X
  1535. X    if ( time < 0L )
  1536. X    {       /* Ignore negative times */
  1537. X        printf( "     " ) ;     
  1538. X        return ;
  1539. X    }
  1540. X    if ( time < Info.i_hz*60L*10L )
  1541. X    {       /* Less than 10 minutes */
  1542. X        printf( "%3D.%1D", time/Info.i_hz,
  1543. X            (time % Info.i_hz / (Info.i_hz/10L)) ) ;
  1544. X        return ;
  1545. X    }
  1546. X    /* If less than 10 hours, print as minutes */
  1547. X    time /= Info.i_hz ;
  1548. X    /* Print as minutes if less than 10 hours ; print as hours if less than
  1549. X       10 days, else print as days. */
  1550. X    if ( time < 60L*60L*10L )               
  1551. X        printf( "%3D M", time/60L ) ;
  1552. X    else if ( time < 24L*60L*60L*10L )
  1553. X        printf( "%3D H", time/60L/60L ) ;
  1554. X    else
  1555. X        printf( "%3D D", time/60L/60L/24L ) ;
  1556. X}
  1557. X
  1558. X# endif
  1559. END_OF_prcpu.c
  1560. if test 1538 -ne `wc -c <prcpu.c`; then
  1561.     echo shar: \"prcpu.c\" unpacked with wrong size!
  1562. fi
  1563. # end of overwriting check
  1564. fi
  1565. if test -f prheader.c -a "${1}" != "-c" ; then 
  1566.   echo shar: Will not over-write existing file \"prheader.c\"
  1567. else
  1568. echo shar: Extracting \"prheader.c\" \(438 characters\)
  1569. sed "s/^X//" >prheader.c <<'END_OF_prheader.c'
  1570. X# include       "sps.h"
  1571. X# include       "flags.h"
  1572. X
  1573. X/* PRHEADER - Print a header according to the switches */
  1574. Xprheader ()
  1575. X{
  1576. X    extern struct flags     Flg ;
  1577. X
  1578. X    printf( "Ty User    %s Proc#", Flg.flg_v ?
  1579. X        " Status Fl Nice Virtual Resident %M  Time Child %C" :
  1580. X        Flg.flg_d ?
  1581. X        "  Files    PageFaults Swap BlockI/O Kbytsecs" : "" ) ;
  1582. X    if ( Flg.flg_f )
  1583. X        printf( " Ppid#" ) ;
  1584. X    if ( Flg.flg_g )
  1585. X        printf( " Pgrp#" ) ;
  1586. X    printf( " Command\n" ) ;
  1587. X}
  1588. END_OF_prheader.c
  1589. if test 438 -ne `wc -c <prheader.c`; then
  1590.     echo shar: \"prheader.c\" unpacked with wrong size!
  1591. fi
  1592. # end of overwriting check
  1593. fi
  1594. if test -f printall.c -a "${1}" != "-c" ; then 
  1595.   echo shar: Will not over-write existing file \"printall.c\"
  1596. else
  1597. echo shar: Extracting \"printall.c\" \(430 characters\)
  1598. sed "s/^X//" >printall.c <<'END_OF_printall.c'
  1599. X# include       <stdio.h>
  1600. X# include       "sps.h"
  1601. X
  1602. X/* PRINTALL - Recursively print the process tree. */
  1603. Xprintall ( p, md )
  1604. X
  1605. Xregister struct process         *p ;
  1606. Xregister int                    md ;
  1607. X
  1608. X{
  1609. X    while ( p )
  1610. X    {       /* Print this process */
  1611. X        printproc( p, md ) ;    
  1612. X        (void)fflush( stdout ) ;
  1613. X        /* Print child processes */
  1614. X        printall( p->pr_child, md+1 ) ;
  1615. X        /* Print brother processes */
  1616. X        p = p->pr_sibling ;     
  1617. X    }
  1618. X}
  1619. END_OF_printall.c
  1620. if test 430 -ne `wc -c <printall.c`; then
  1621.     echo shar: \"printall.c\" unpacked with wrong size!
  1622. fi
  1623. # end of overwriting check
  1624. fi
  1625. if test -f prsummary.c -a "${1}" != "-c" ; then 
  1626.   echo shar: Will not over-write existing file \"prsummary.c\"
  1627. else
  1628. echo shar: Extracting \"prsummary.c\" \(632 characters\)
  1629. sed "s/^X//" >prsummary.c <<'END_OF_prsummary.c'
  1630. X# include       "sps.h"
  1631. X
  1632. X/* PRSUMMARY - Print the summarising information */
  1633. Xprsummary ()
  1634. X{
  1635. X    extern struct summary   Summary ;
  1636. X
  1637. X    printf(
  1638. X"%D (%Dk) processes, %D (%Dk) busy, %D (%Dk) loaded, %D (%Dk) swapped\n",
  1639. X        Summary.sm_ntotal, KBYTES( Summary.sm_ktotal ),
  1640. X        Summary.sm_nbusy, KBYTES( Summary.sm_kbusy ),
  1641. X        Summary.sm_nloaded, KBYTES( Summary.sm_kloaded ),
  1642. X        Summary.sm_nswapped, KBYTES( Summary.sm_kswapped ) ) ;
  1643. X    Summary.sm_ntotal = 0L ;
  1644. X    Summary.sm_ktotal = 0L ;
  1645. X    Summary.sm_nbusy = 0L ;
  1646. X    Summary.sm_kbusy = 0L ;
  1647. X    Summary.sm_nloaded = 0L ;
  1648. X    Summary.sm_kloaded = 0L ;
  1649. X    Summary.sm_nswapped = 0L ;
  1650. X    Summary.sm_kswapped = 0L ;
  1651. X}
  1652. END_OF_prsummary.c
  1653. if test 632 -ne `wc -c <prsummary.c`; then
  1654.     echo shar: \"prsummary.c\" unpacked with wrong size!
  1655. fi
  1656. # end of overwriting check
  1657. fi
  1658. if test -f readstatus.c -a "${1}" != "-c" ; then 
  1659.   echo shar: Will not over-write existing file \"readstatus.c\"
  1660. else
  1661. echo shar: Extracting \"readstatus.c\" \(1170 characters\)
  1662. sed "s/^X//" >readstatus.c <<'END_OF_readstatus.c'
  1663. X# include       "sps.h"
  1664. X# include       <h/text.h>
  1665. X
  1666. X/* READSTATUS - Reads the kernel memory for current processes and texts */
  1667. Xreadstatus ( process, text )
  1668. X
  1669. Xregister struct process         *process ;
  1670. Xstruct text                     *text ;
  1671. X
  1672. X{
  1673. X    register struct proc    *p ;
  1674. X    register struct proc    *p0 ;
  1675. X    register struct process *pr ;
  1676. X    extern struct info      Info ;
  1677. X    extern int              Flkmem ;
  1678. X    char                    *getcore() ;
  1679. X
  1680. X    /* Read current text information */
  1681. X    memseek( Flkmem, (long)Info.i_text0 ) ;
  1682. X    if ( read( Flkmem, (char*)text, Info.i_ntext * sizeof( struct text ) )
  1683. X    != Info.i_ntext * sizeof( struct text ) )
  1684. X        prexit( "sps - Can't read system text table\n" ) ;
  1685. X    /* Read current process information */
  1686. X    p0 = (struct proc*)getcore( sizeof( struct proc )*Info.i_nproc ) ;
  1687. X    memseek( Flkmem, (long)Info.i_proc0 ) ;
  1688. X    if ( read( Flkmem, (char*)p0, Info.i_nproc * sizeof( struct proc ) )
  1689. X    != Info.i_nproc * sizeof( struct proc ) )
  1690. X        prexit( "sps - Can't read system process table\n" ) ;
  1691. X    /* Copy process information into our own array */
  1692. X    for ( p = p0, pr = process ; pr < &process[ Info.i_nproc ] ; p++, pr++ )
  1693. X        pr->pr_p = *p ;
  1694. X    free( (char*)p0 ) ;
  1695. X}
  1696. END_OF_readstatus.c
  1697. if test 1170 -ne `wc -c <readstatus.c`; then
  1698.     echo shar: \"readstatus.c\" unpacked with wrong size!
  1699. fi
  1700. # end of overwriting check
  1701. fi
  1702. if test -f selectproc.c -a "${1}" != "-c" ; then 
  1703.   echo shar: Will not over-write existing file \"selectproc.c\"
  1704. else
  1705. echo shar: Extracting \"selectproc.c\" \(1885 characters\)
  1706. sed "s/^X//" >selectproc.c <<'END_OF_selectproc.c'
  1707. X# include       "sps.h"
  1708. X# include       "flags.h"
  1709. X# ifdef USELOGINUID
  1710. X# include    <pwd.h>
  1711. X# endif USELOGINUID
  1712. X
  1713. X/*
  1714. X** SELECTPROC - Given a process structure, this procedure decides whether
  1715. X** the process is a candidate for printing.
  1716. X*/
  1717. Xselectproc ( p, process, thisuid )
  1718. X
  1719. Xregister struct process         *p ;            
  1720. Xregister struct process         *process ;      
  1721. Xint                thisuid ;
  1722. X
  1723. X{
  1724. X    register union flaglist *fp ;
  1725. X    register struct process *pp ;
  1726. X#ifdef USELOGINUID
  1727. X    char            *username ;
  1728. X    struct passwd        *pw ;
  1729. X    char            *getlogin() ;
  1730. X    struct passwd        *getpwnam() ;
  1731. X#endif USELOGINUID
  1732. X    extern struct flags     Flg ;
  1733. X
  1734. X    /* Flg.flg_AZ is an internal flag set if one of flags `A' to `Z'
  1735. X       was specified. If this is not set, a process is listed only
  1736. X       if it or one of its ancestors belongs to the invoking user. */
  1737. X    if ( !Flg.flg_AZ )
  1738. X    {
  1739. X#ifdef USELOGINUID
  1740. X        thisuid = (username = getlogin())
  1741. X            && (pw = getpwnam( username )) ? pw->pw_uid : getuid() ;
  1742. X#endif USELOGINUID
  1743. X        for ( pp = p ; pp > &process[1] ; pp = pp->pr_pptr )
  1744. X            if ( thisuid == pp->pr_p.p_uid )
  1745. X                return ( 1 ) ;
  1746. X    }
  1747. X    if ( Flg.flg_A )
  1748. X        return ( 1 ) ;
  1749. X    if ( Flg.flg_P )
  1750. X        for ( fp = Flg.flg_Plist ; fp->f_pid >= 0 ; fp++ )
  1751. X            if ( fp->f_pid == p->pr_p.p_pid )
  1752. X                return ( 1 ) ;
  1753. X    if ( Flg.flg_U )
  1754. X        for ( pp = p ; pp > &process[1] ; pp = pp->pr_pptr )
  1755. X            for ( fp = Flg.flg_Ulist ; fp->f_uid >= 0 ; fp++ )
  1756. X                if ( fp->f_uid == pp->pr_p.p_uid )
  1757. X                    return ( 1 ) ;
  1758. X    switch ( p->pr_p.p_stat )
  1759. X    {
  1760. X        case SRUN :
  1761. X            if ( Flg.flg_B )
  1762. X                return ( 1 ) ;
  1763. X            break ;
  1764. X        case SSLEEP :
  1765. X            if ( Flg.flg_B
  1766. X            &&   p->pr_p.p_pri < PZERO && p->pr_p.p_pid > MSPID )
  1767. X                return ( 1 ) ;
  1768. X        case SWAIT :
  1769. X        case SIDL :
  1770. X            if ( Flg.flg_W )
  1771. X                return ( 1 ) ;
  1772. X            break ;
  1773. X        case SSTOP :
  1774. X            if ( Flg.flg_S )
  1775. X                return ( 1 ) ;
  1776. X            break ;
  1777. X        case SZOMB :
  1778. X            if ( Flg.flg_Z )
  1779. X                return ( 1 ) ;
  1780. X            break ;
  1781. X        default :
  1782. X            break ;
  1783. X    }
  1784. X    return ( 0 ) ;
  1785. X}
  1786. END_OF_selectproc.c
  1787. if test 1885 -ne `wc -c <selectproc.c`; then
  1788.     echo shar: \"selectproc.c\" unpacked with wrong size!
  1789. fi
  1790. # end of overwriting check
  1791. fi
  1792. if test -f selecttty.c -a "${1}" != "-c" ; then 
  1793.   echo shar: Will not over-write existing file \"selecttty.c\"
  1794. else
  1795. echo shar: Extracting \"selecttty.c\" \(368 characters\)
  1796. sed "s/^X//" >selecttty.c <<'END_OF_selecttty.c'
  1797. X# include       "sps.h"
  1798. X# include       "flags.h"
  1799. X
  1800. X/* SELECTTTY - Decides whether this process is interesting for its tty */
  1801. Xselecttty ( p )
  1802. X
  1803. Xregister struct process         *p ;
  1804. X
  1805. X{
  1806. X    register union flaglist *fp ;
  1807. X    extern struct flags     Flg ;
  1808. X
  1809. X    for ( fp = Flg.flg_Tlist ; fp->f_ttyline ; fp++ )
  1810. X        if ( fp->f_ttyline == p->pr_tty )
  1811. X            return ( 1 ) ;
  1812. X    return ( 0 ) ;
  1813. X}
  1814. END_OF_selecttty.c
  1815. if test 368 -ne `wc -c <selecttty.c`; then
  1816.     echo shar: \"selecttty.c\" unpacked with wrong size!
  1817. fi
  1818. # end of overwriting check
  1819. fi
  1820. if test -f termwidth.c -a "${1}" != "-c" ; then 
  1821.   echo shar: Will not over-write existing file \"termwidth.c\"
  1822. else
  1823. echo shar: Extracting \"termwidth.c\" \(691 characters\)
  1824. sed "s/^X//" >termwidth.c <<'END_OF_termwidth.c'
  1825. X#include    <sys/ioctl.h>
  1826. X
  1827. X/*
  1828. X** TERMWIDTH - Sets the external variable `Termwidth' to the # of columns
  1829. X** on the terminal.
  1830. X*/
  1831. Xtermwidth ()
  1832. X{
  1833. X    register char           *termtype ;
  1834. X    register int            twidth ;
  1835. X#ifdef TIOCGWINSZ
  1836. X    struct winsize        w ;
  1837. X#endif
  1838. X    char                    buf[ 1025 ] ;
  1839. X    extern unsigned         Termwidth ;
  1840. X    char                    *getenv() ;
  1841. X
  1842. X#ifdef TIOCGWINSZ
  1843. X    w.ws_col = 0 ;
  1844. X    if ( !ioctl( 0, TIOCGWINSZ, &w ) && w.ws_col )
  1845. X    {
  1846. X        Termwidth = w.ws_col ;
  1847. X        return ;
  1848. X    }
  1849. X#endif
  1850. X    Termwidth = 80 ;
  1851. X    if ( !(termtype = getenv( "TERM" )) )
  1852. X        return ;
  1853. X    if ( tgetent( buf, termtype ) != 1 )
  1854. X        return ;
  1855. X    twidth = tgetnum( "co" ) ;
  1856. X    if ( twidth > 40 )
  1857. X        Termwidth = twidth ;
  1858. X}
  1859. END_OF_termwidth.c
  1860. if test 691 -ne `wc -c <termwidth.c`; then
  1861.     echo shar: \"termwidth.c\" unpacked with wrong size!
  1862. fi
  1863. # end of overwriting check
  1864. fi
  1865. if test -f ttystatus.c -a "${1}" != "-c" ; then 
  1866.   echo shar: Will not over-write existing file \"ttystatus.c\"
  1867. else
  1868. echo shar: Extracting \"ttystatus.c\" \(2911 characters\)
  1869. sed "s/^X//" >ttystatus.c <<'END_OF_ttystatus.c'
  1870. X# include       "sps.h"
  1871. X# include       "flags.h"
  1872. X# include       <stdio.h>
  1873. X# include       <h/ioctl.h>
  1874. X# include       <h/tty.h>
  1875. X# ifdef CHAOS
  1876. X# include       <chunix/chsys.h>
  1877. X# include       <chaos/chaos.h>
  1878. X# endif
  1879. X
  1880. X/*
  1881. X** TTYSTATUS - Reads the kernel memory for tty structures of active processes.
  1882. X** The addresses of the associated struct ttys of /dev/kmem are kept in the
  1883. X** info structure. Here we use those addresses to access the structures.
  1884. X** Actually, we are mostly interested just in the process group of each tty.
  1885. X*/
  1886. Xttystatus ()
  1887. X{
  1888. X    register struct ttyline *lp ;
  1889. X    struct tty              tty ;
  1890. X    extern struct flags     Flg ;
  1891. X    extern struct info      Info ;
  1892. X    extern int              Flkmem ;
  1893. X
  1894. X    if ( Flg.flg_y )
  1895. X        printf( "Ty   Dev       Addr Rawq Canq Outq  Pgrp\n" ) ;
  1896. X    lp = Info.i_ttyline ;
  1897. X# ifdef CHAOS
  1898. X    while ( lp->l_name[0] && lp->l_name[0] != 'C' )
  1899. X# else
  1900. X    while ( lp->l_name[0] )
  1901. X# endif
  1902. X    {
  1903. X        memseek( Flkmem, (long)lp->l_addr ) ;
  1904. X        if ( read( Flkmem, (char*)&tty, sizeof( struct tty ) )
  1905. X        != sizeof( struct tty ) )
  1906. X        {
  1907. X            fprintf( stderr,
  1908. X                "sps - Can't read struct tty for tty%.2s\n",
  1909. X                lp->l_name ) ;
  1910. X            lp->l_pgrp = 0 ;
  1911. X            lp++ ;
  1912. X            continue ;
  1913. X        }
  1914. X        lp->l_pgrp = tty.t_pgrp ;
  1915. X        prtty( lp, &tty ) ;
  1916. X        lp++ ;
  1917. X    }
  1918. X# ifdef CHAOS
  1919. X    chaosttys( lp ) ;               
  1920. X# endif
  1921. X}
  1922. X
  1923. X/* PRTTY - Print out the tty structure */
  1924. Xprtty ( lp, tty )
  1925. X
  1926. Xregister struct ttyline         *lp ;
  1927. Xregister struct tty             *tty ;
  1928. X
  1929. X{
  1930. X    extern struct flags     Flg ;
  1931. X
  1932. X    if ( !Flg.flg_y )
  1933. X        return ;
  1934. X    printf( "%-2.2s %2d,%2d 0x%08x %4d %4d %4d %5d\n",
  1935. X        lp->l_name,
  1936. X        major( lp->l_dev ),
  1937. X        minor( lp->l_dev ),
  1938. X        lp->l_addr,
  1939. X        tty->t_rawq.c_cc,
  1940. X        tty->t_canq.c_cc,
  1941. X        tty->t_outq.c_cc,
  1942. X        tty->t_pgrp ) ;
  1943. X}
  1944. X
  1945. X# ifdef CHAOS
  1946. X
  1947. X/* CHAOSTTYS - Finds ttys attached to the Chaos net */
  1948. Xchaosttys ( lp )
  1949. X
  1950. Xregister struct ttyline         *lp ;
  1951. X
  1952. X{
  1953. X    register struct connection      **cnp ;
  1954. X    register int                    i ;
  1955. X    struct tty                      tty ;
  1956. X    struct connection               *conntab[CHNCONNS] ;
  1957. X    struct connection               conn ;
  1958. X    extern struct info              Info ;
  1959. X    extern int                      Flkmem ;
  1960. X
  1961. X    memseek( Flkmem, (long)Info.i_Chconntab ) ;
  1962. X    (void)read( Flkmem, (char*)conntab, sizeof( conntab ) ) ;
  1963. X    for ( i = 0, cnp = conntab ; cnp < &conntab[CHNCONNS] ; i++, cnp++ )
  1964. X    {
  1965. X        if ( !*cnp )
  1966. X            continue ;
  1967. X        memseek( Flkmem, (long)*cnp ) ;
  1968. X        (void)read( Flkmem, (char*)&conn, sizeof( struct connection ) );
  1969. X        if ( !(conn.cn_flags & CHTTY) )
  1970. X            continue ;
  1971. X        memseek( Flkmem, (long)conn.cn_ttyp ) ;
  1972. X        (void)read( Flkmem, (char*)&tty, sizeof( struct tty ) ) ;
  1973. X        if ( lp >= &Info.i_ttyline[MAXTTYS] )
  1974. X            prexit( "sps - Too many chaos ttys\n" ) ;
  1975. X        lp->l_addr = conn.cn_ttyp ;
  1976. X        lp->l_pgrp = tty.t_pgrp ;
  1977. X        lp->l_dev = tty.t_dev ;
  1978. X        lp->l_name[0] = 'C' ;
  1979. X        lp->l_name[1] = i < 10 ? '0'+i : i-10 <= 'z'-'a' ? i-10+'a' :
  1980. X                i-10-('z'-'a')+'A' ;
  1981. X        prtty( lp, &tty ) ;
  1982. X        lp++ ;
  1983. X    }
  1984. X}
  1985. X
  1986. X# endif
  1987. END_OF_ttystatus.c
  1988. if test 2911 -ne `wc -c <ttystatus.c`; then
  1989.     echo shar: \"ttystatus.c\" unpacked with wrong size!
  1990. fi
  1991. # end of overwriting check
  1992. fi
  1993. echo shar: End of archive 1 \(of 3\).
  1994. cp /dev/null ark1isdone
  1995. MISSING=""
  1996. for I in 1 2 3 ; do
  1997.     if test ! -f ark${I}isdone ; then
  1998.     MISSING="${MISSING} ${I}"
  1999.     fi
  2000. done
  2001. if test "${MISSING}" = "" ; then
  2002.     echo You have unpacked all 3 archives.
  2003.     rm -f ark[1-9]isdone
  2004. else
  2005.     echo You still need to unpack the following archives:
  2006.     echo "        " ${MISSING}
  2007. fi
  2008. ##  End of shell archive.
  2009. exit 0
  2010. -- 
  2011.  
  2012. Rich $alz            "Anger is an energy"
  2013. Cronus Project, BBN Labs    rsalz@bbn.com
  2014. Moderator, comp.sources.unix    sources@uunet.uu.net
  2015.