home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume10 / top_s375 / part01 next >
Internet Message Format  |  1987-07-21  |  61KB
  1. Path: uunet!rs
  2. From: rs@uunet.UU.NET (Rich Salz)
  3. Newsgroups: comp.sources.unix
  4. Subject: v10i063:  Top users display, 2.1 with Symmetric changes, Part01/02
  5. Message-ID: <692@uunet.UU.NET>
  6. Date: 23 Jul 87 00:24:13 GMT
  7. Organization: UUNET Communications Services, Arlington, VA
  8. Lines: 2065
  9. Approved: rs@uunet.UU.NET
  10.  
  11. Submitted-by: hoptoad!vixie!paul (Paul Vixie Esq)
  12. Posting-Number: Volume 10, Issue 63
  13. Archive-name: top_s375/Part01
  14.  
  15. Rich--  I've had this floating around for a while now.  I got it from the
  16. net, at which time it ran on Vax, Sun, and Pyramid systems.  It still does,
  17. but I've added a bunch of #ifdef and #ifndef to make it work on the Symmetric
  18. 375.  I recently recompiled for a Vax, and it seems still to work quite well
  19. there -- so I don't think I screwed anything up.
  20.  
  21. This is Stable Code -- it has run on three Symmetric 375s for five months or
  22. so now, with no changes.  You can bypass your usual policy of waiting a while
  23. for the author (or in my case, sender) of sources to change their mind and
  24. send in last-minute updates or whatever...
  25.  
  26. I tried to send mail to the author, but he did not respond.  Perhaps he'll
  27. see this and integrate my changes into 2.2 (if such there be).
  28.  
  29. #! /bin/sh
  30. ##  This is a shell archive.  Remove anything before this line, then unpack
  31. ##  it by saving it into a file and typing "sh file".  To overwrite existing
  32. ##  files, type "sh file -c".  You can also feed this as standard input via
  33. ##  unshar, or by typing "sh <file".  If this archive is complete, you will
  34. ##  see the following message at the end:
  35. #        "End of archive 1 (of 2)."
  36. # Contents:  CHANGES.scs Changes MANIFEST Makefile Manifest README
  37. #   boolean.h bzero.c commands.c getopt.c kernel.c layout.h screen.c
  38. #   screen.h sigconv.awk sigdesc.h top.h top.local.h top.man
  39. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  40. if test -f CHANGES.scs -a "${1}" != "-c" ; then 
  41.   echo shar: Will not over-write existing file \"CHANGES.scs\"
  42. else
  43. echo shar: Extracting \"CHANGES.scs\" \(1514 characters\)
  44. sed "s/^X//" >CHANGES.scs <<'END_OF_CHANGES.scs'
  45. XChanges for Symmetric Computer Systems s/375 (preprocessor constant: scs).
  46. X
  47. XThese changes were not made at, by, or for SCS proper.  SCS would probably
  48. Xbe interested in them, but so far only the users' group has them.  They were
  49. Xmade in February, 1987, to version 2.1 of the program, by Paul Vixie
  50. X(dual!ptsfa!vixie!paul@ucbvax.Berkeley.EDU).
  51. X
  52. XSome code cleanup was done, some for appearance sake, some (e.g., fmt_proc() in
  53. Xdisplay.c) actually structural improvements.
  54. X
  55. XThe SCS kernel is basically 4.2, but with a number of differences -- some I
  56. Xlike, others I don't.  The list:
  57. X
  58. X    all page counts are in kilobytes (all the ones I had to use, anyway);
  59. X    PGSHIFT is defined as 9 in <machine/param.h>, this may be an error;
  60. X    the physical page size is 512, but the kernel pages are 1024. sigh...
  61. X
  62. X    in the proc structure, there is no p_rssize; p_tsize and p_dsize are
  63. X    also missing, though combined in p_tdsize (whose value is in BYTES,
  64. X    NOT PAGES).  p_ssize has either 0 or 16MB as its value, and is there-
  65. X    fore useless.  p_addr is missing...
  66. X
  67. X    ...however, there is a field p_spti which indexes into the page table
  68. X    table.  each spt has a value telling how many pages are used (total
  69. X    reference code), and how many are actually in memory.  these were used
  70. X    for the "SIZE" and "RES" fields on the display...
  71. X
  72. X    ...the lack of p_addr made it hard to find the U area for a proc, but
  73. X    since SCS put the process name and CPU time into the proc structure
  74. X    for use when ^T (info) is pressed, the U area wasn't needed anyway...
  75. END_OF_CHANGES.scs
  76. if test 1514 -ne `wc -c <CHANGES.scs`; then
  77.     echo shar: \"CHANGES.scs\" unpacked with wrong size!
  78. fi
  79. # end of overwriting check
  80. fi
  81. if test -f Changes -a "${1}" != "-c" ; then 
  82.   echo shar: Will not over-write existing file \"Changes\"
  83. else
  84. echo shar: Extracting \"Changes\" \(7151 characters\)
  85. sed "s/^X//" >Changes <<'END_OF_Changes'
  86. XMon Oct  6 1986 - wnl (2.1)
  87. X    A bug with the kill command was pointed out by "dciem!tim"---
  88. X    specifying a signal by name did not work correctly.  This bug has
  89. X    been fixed with a simple change to commands.c.  Another bug made
  90. X    the cpu state percentages incorrect the first time they were
  91. X    displayed.  This bug has also been fixed (changed top.c).
  92. X
  93. XThu Sep  4 1986 - wnl (2.0, at last)
  94. X    This is the version that will (hopefully) get released to the
  95. X    world as top 2.0.
  96. X    Added the "r" and "k" commands for renice and kill, respectively.
  97. X    This required adding a way to handle system call errors, and the
  98. X    addition of the "e" command.  Help screen and manual page were
  99. X    changed to reflect this change.  Changed all "#ifdef SUN" directives
  100. X    to "#ifdef sun", and changed all "#ifdef PYRAMID" directives to
  101. X    "#ifdef pyr".  As much as I hate those choices of preprocessor
  102. X    names (they too easily conflict with real variable names), it does
  103. X    make automatic compilation possible---people don't have to change
  104. X    the Makefile anymore for specific machines.  The manual page was
  105. X    changed to automatically incorporate the defaults as set in the
  106. X    Makefile (including an infinite value for TOPN) and the way the
  107. X    manual page is generated by the Makefile was changed to make
  108. X    maintenance of this information automatic.
  109. X
  110. XMon Jul 28 1986 - wnl (still pre 2.0)
  111. X    Real close now.  I put in a new definition for the macro "pagetok"
  112. X    that does an explicit shift of a constant expression involving
  113. X    PGSHIFT.  Appropriate checks are made if PGSHIFT is to small.
  114. X    "pagetok" is now used exclusively everywhere to convert kernel
  115. X    clicks to kilobytes.  I added a full blown interactive mode with
  116. X    the ability to change some of the runtime parameters (how many to
  117. X    display, time delay, etc.) while top is running.  I also
  118. X    incorporated a few ideas from the net:  control characters in the
  119. X    command name are replaced with '?'; the '-S' option makes the
  120. X    swapper and pager visible; options have been added to control the
  121. X    number of displays produced (this makes it easier to make
  122. X    performance snapshots with top).  I have also added the notion of
  123. X    "infinite" values for number of processes and number of displays.
  124. X    I fixed a long-standing bug in the uid to username mapping code
  125. X    that was only aggravated on the pyramids:  it was an ill-defined
  126. X    expression (akin to i = i++).  I tweaked the proc_compar routine
  127. X    for qsort slightly so that stopped processes were more likely to
  128. X    show up.  Manual page was updated to reflect all changes
  129. X    noticeable to the user.
  130. X
  131. XTue Jul  1 1986 - wnl (pre 2.0 -- 1.9999?)
  132. X    In the process of major revamping on the way to version 2.0.
  133. X    I have completely done away with curses by adding my own screen
  134. X    management routines in a separate file (screen.c).  The rationale
  135. X    for this is that top knows a whole lot more about what is and is
  136. X    not redundant on the screen and can compare simple integer values
  137. X    where curses would have to compare strings.  This has turned out
  138. X    to be a very big win speed-wise.  The proc_compar routine for
  139. X    sorting has been rewritten to include several more keys.  I
  140. X    decided this was necessary when I noticed that the "top" process
  141. X    itself kept disappearing off the top 10 list on a Sun-3.  All the
  142. X    processes had the same percentage (0%) and the sort wasn't really
  143. X    doing anything worthwhile.  I changed the expression that computes
  144. X    memory usage to use the ctob macro instead of just assuming that
  145. X    pages were 512 bytes.  More work still needs to be done before
  146. X    this version is usable.  I changed options-processing to use
  147. X    getopt and added appropriate incantations to the Makefile.
  148. X
  149. XWed Feb 20 1985 - wnl (still 1.8)
  150. X    Put in the ifdef FOUR_ONE statements to make top still compilable
  151. X    on a 4.1 system.  Apparently, there are some users out there that
  152. X    need this functionality.  Oh well.  I don't guarantee any of it,
  153. X    since I can't test it.  Made appropriate changes to README and
  154. X    final installation related changes to Makefile.
  155. X
  156. XSat Feb  2 1985 - wnl (1.8)
  157. X    Removed all the ifdef FOUR_TWO statements and made "top" into a
  158. X    4.2 only program.  If someone really wants to still run it on 4.1,
  159. X    then they can do all the work.  We don't have a 4.1 machine
  160. X    anymore, so I don't even know if the thing still works under 4.1.
  161. X    Cleaned up the Makefile and the README.  Added installation rules
  162. X    to the Makefile, as requested by several sites.  Fixed a very
  163. X    obscure divide-by-zero bug.  Added a second "key" to the qsort
  164. X    comparison function (proc_compar) so that comparisons are based on
  165. X    cpu ticks if the percentages are equal (provided by Jonathon
  166. X    Feiber at Sun).
  167. X
  168. XTue Dec 11 1984 - wnl (1.7)
  169. X    Added the virtual and real memory status line to the header area
  170. X    (provided by Jonathon Feiber at Sun)
  171. X
  172. XTue Nov 20 1984 - wnl (1.6)
  173. X    Added an "exit" if sbrk's fail.  Added changes from Jonathon
  174. X    Feiber at Sun:  ifdef SUN to make top work on Suns (they don't use
  175. X    doubles in the proc structure), register declarations, check for
  176. X    getting a user structure that has disappeared since the proc array
  177. X    was read (it used to die, now it just shows the process as swapped).
  178. X
  179. XTue Nov 13 1984 - wnl (1.5)
  180. X    If the number of displayable processes ("active_procs") was less
  181. X    than the number of requested processes ("topn"), top would
  182. X    segmentation fault.  This bug has been fixed.  Thanks to Prentiss
  183. X    Riddle at ut-sally for pointing out the existence of this bug.
  184. X
  185. XTue Oct 23 1984 - wnl (1.4)
  186. X    Finally fixed the hash table bug that caused processes owned by
  187. X    root to sometimes appear with either no name or a different name
  188. X    that had UID 0 (such as "operator").  Removed all the ifdef DEBUG
  189. X    blocks to make top ready for distribution to the real world.
  190. X
  191. XSun Apr  8 1984 - wnl (still 1.3)
  192. X    Made some slight changes to the display format.  It now looks more
  193. X    aesthetically pleasing.  Added some preprocessor constants so that
  194. X    the two defaults (number of processes and seconds of delay) easier
  195. X    to change.
  196. X
  197. XThu Apr  5 1984 - wnl (1.3)
  198. X    Changed the order in which things are done at initialization time.
  199. X    This way, if an error occurs before starting the main loop, curses
  200. X    will never get started.  Also changed other error handlers so that
  201. X    endwin() is called before any flavor of exit.  Specifying a number
  202. X    of processes that is more than the screen can handle is no longer
  203. X    fatal.  It displays a warning message and pretends the user
  204. X    specified the maximum for the screen.  Finally cured all the TSTP
  205. X    blues (well, almost all).  I removed my TSTP handler and convinced
  206. X    the system to always use the one that curses sets up.  Turns out
  207. X    that "sleep" was stepping all over it during a pause.  So, I don't
  208. X    use sleep anymore.  The only problem that remains with it now is
  209. X    redrawing the old display before updating it after a pause.
  210. X
  211. XTue Apr  3 1984 - wnl (from 1.0 to 1.2)
  212. X    I changed the format of the TIME column from just "seconds" to
  213. X    "minutes:seconds".  I also made pausing work correctly.  Screen
  214. X    redraws with an up to date display.  For compatibility with 4.2, I
  215. X    changed the name of the "zero" function to "bzero".  The makefile
  216. X    has been altered to handle versions for 4.1 and 4.2, and README
  217. X    has been updated to reflect these recent changes.
  218. END_OF_Changes
  219. if test 7151 -ne `wc -c <Changes`; then
  220.     echo shar: \"Changes\" unpacked with wrong size!
  221. fi
  222. # end of overwriting check
  223. fi
  224. if test -f MANIFEST -a "${1}" != "-c" ; then 
  225.   echo shar: Will not over-write existing file \"MANIFEST\"
  226. else
  227. echo shar: Extracting \"MANIFEST\" \(589 characters\)
  228. sed "s/^X//" >MANIFEST <<'END_OF_MANIFEST'
  229. XChanges                      1
  230. XMANIFEST                     2
  231. XMakefile                     1
  232. XManifest                     1
  233. XREADME                       1
  234. Xboolean.h                    1
  235. Xbzero.c                      1
  236. Xcommands.c                   1
  237. Xdisplay.c                    1
  238. Xgetopt.c                     1
  239. Xkernel.c                     1
  240. Xlayout.h                     1
  241. Xscreen.c                     1
  242. Xscreen.h                     1
  243. Xsigconv.awk                  1
  244. Xtop.c                        2
  245. Xtop.h                        1
  246. Xtop.local.h                  2
  247. Xtop.man                      2
  248. END_OF_MANIFEST
  249. if test 589 -ne `wc -c <MANIFEST`; then
  250.     echo shar: \"MANIFEST\" unpacked with wrong size!
  251. fi
  252. # end of overwriting check
  253. fi
  254. if test -f Makefile -a "${1}" != "-c" ; then 
  255.   echo shar: Will not over-write existing file \"Makefile\"
  256. else
  257. echo shar: Extracting \"Makefile\" \(2899 characters\)
  258. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  259. X# Makefile for "top", a top 10 process display for Unix
  260. X#
  261. X# This makefile is for top, version 2.1
  262. X#
  263. X# Written by William LeFebvre, Rice University graduate student
  264. X
  265. X# installation information:
  266. X#    OWNER    - name (or uid) for the installed executable's owner
  267. X#    GROUP    - group name (or gid) for the installed executable's group
  268. X#    MODE    - mode for the installed executable (should start with a 0)
  269. X#    BINDIR    - directory where the executable should live
  270. X#    MANDIR    - directory where the manual page should live
  271. X#    MAN    - troff macros for manual pages
  272. X#    TROFF    - most appropriate troff command
  273. X
  274. XOWNER  = root
  275. XGROUP  = daemon
  276. XMODE   = 755
  277. XBINDIR = /usr/local/bin
  278. XMANDIR = /usr/man/manl
  279. XMAN    = man
  280. XTROFF  = nroff
  281. X
  282. X# Values for the two defaults in "top":
  283. X#    TOPN    - default number of processes to display
  284. X#    DELAY    - default delay between updates
  285. X#
  286. X# set TOPN to -1 to indicate infinity (so that top will display as many
  287. X# as the screen will hold).
  288. X
  289. XTOPN = -1
  290. XDELAY = 5
  291. X
  292. XTABLE =
  293. X# Top maintains an internal hash table for translating uid to username.
  294. X# This hash table must be big enough to hold every name in /etc/passwd.
  295. X# It is possible, but not necessary, to specify the hash table size in
  296. X# this Makefile.  Just uncomment the following line and provide a number.
  297. X#TABLE = -DTable_size=
  298. X
  299. XTARFILES = README Changes Makefile top.c commands.c display.c kernel.c \
  300. X       screen.c getopt.c \
  301. X       boolean.h layout.h screen.h top.h top.local.h bzero.c \
  302. X       sigconv.awk top.man
  303. XOBJS = top.o commands.o display.o kernel.o screen.o getopt.o
  304. X
  305. X# Top uses the preprocessor variables "sun", "pyr" and "scs" for specific
  306. X# changes required by Suns, Pyramids and Symmetrics.  No changes to "CFLAGS"
  307. X# are required for these architectres.
  308. XCFLAGS = -O
  309. X# To make a version for 4.1, comment out the previous line and
  310. X# uncomment the following two lines:
  311. X#CFLAGS = -DFOUR_ONE -O
  312. X#OBJS = top.o commands.o display.o kernel.o screen.o getopt.o bzero.o
  313. X
  314. Xall: top top.1
  315. X
  316. Xtop: $(OBJS)
  317. X    cc $(CFLAGS) -o top $(OBJS) -ltermlib -lm
  318. X
  319. Xtop.o: top.c Makefile
  320. X    cc $(CFLAGS) -c $(TABLE) -DDefault_TOPN=$(TOPN) -DDefault_DELAY=$(DELAY) top.c
  321. X
  322. X# include file dependencies
  323. Xtop.o: boolean.h layout.h screen.h top.h top.local.h
  324. Xcommands.o: sigdesc.h
  325. Xdisplay.o: boolean.h layout.h screen.h top.h
  326. Xkernel.o: top.local.h
  327. Xscreen.o: boolean.h screen.h
  328. X
  329. X# automatically built include file
  330. Xsigdesc.h: sigconv.awk /usr/include/signal.h
  331. X    awk -f sigconv.awk /usr/include/signal.h >sigdesc.h
  332. X
  333. X# top.1 is built by combining the actual text with the default information
  334. Xtop.1: top.man Makefile
  335. X    echo '.nr N' $(TOPN) > top.1
  336. X    echo '.nr D' $(DELAY) >>top.1
  337. X    cat top.man >>top.1
  338. X
  339. Xtop.cat: top.1
  340. X    nroff -$(MAN) top.1 | cat -s >top.cat
  341. X
  342. Xtroff: top.1
  343. X    $(TROFF) -man top.1
  344. X
  345. Xtar:
  346. X    rm -f top.tar
  347. X    tar cvf top.tar $(TARFILES)
  348. X
  349. Xclean:
  350. X    rm -f *.o top top.cat top.tar top.1 core
  351. X
  352. Xinstall: top top.1
  353. X    install -s -o $(OWNER) -m $(MODE) -g $(GROUP) top $(BINDIR)
  354. X    install -c top.1 $(MANDIR)
  355. END_OF_Makefile
  356. if test 2899 -ne `wc -c <Makefile`; then
  357.     echo shar: \"Makefile\" unpacked with wrong size!
  358. fi
  359. # end of overwriting check
  360. fi
  361. if test -f Manifest -a "${1}" != "-c" ; then 
  362.   echo shar: Will not over-write existing file \"Manifest\"
  363. else
  364. echo shar: Extracting \"Manifest\" \(161 characters\)
  365. sed "s/^X//" >Manifest <<'END_OF_Manifest'
  366. XChanges
  367. XMakefile
  368. XManifest
  369. XREADME
  370. Xboolean.h
  371. Xbzero.c
  372. Xcommands.c
  373. Xdisplay.c
  374. Xgetopt.c
  375. Xkernel.c
  376. Xlayout.h
  377. Xscreen.c
  378. Xscreen.h
  379. Xsigconv.awk
  380. Xtop.c
  381. Xtop.h
  382. Xtop.local.h
  383. Xtop.man
  384. END_OF_Manifest
  385. if test 161 -ne `wc -c <Manifest`; then
  386.     echo shar: \"Manifest\" unpacked with wrong size!
  387. fi
  388. # end of overwriting check
  389. fi
  390. if test -f README -a "${1}" != "-c" ; then 
  391.   echo shar: Will not over-write existing file \"README\"
  392. else
  393. echo shar: Extracting \"README\" \(5259 characters\)
  394. sed "s/^X//" >README <<'END_OF_README'
  395. XThis file contains a few comments about "top", version 2.0
  396. X
  397. X"top" is a program that will give continual reports about the state of the
  398. Xsystem, including a list of the top cpu using processes.  It requires read
  399. Xaccess to the memory files "/dev/kmem" and "/dev/mem" as well as the system
  400. Ximage "/vmunix".  Some installations have these files protected from general
  401. Xaccess.  These sites would have to install this program in the same way that
  402. Xprograms such as "ps" are installed.
  403. X
  404. XCAVEAT:  version 2.0 of top has internal commands that kill and renice
  405. Xprocesses.  DO NOT INSTALL TOP AS A SETUID PROGRAM, or you will open up a
  406. Xbig security hole since top makes no process ownership checks on its own.
  407. XNote that it is still safe to install top as a set group-id program, since
  408. Xgroup-id has no bearing on who can renice or send signals to what processes.
  409. X
  410. XThere are a few things that need to be checked before compiling the program:
  411. X
  412. XThe most important item is the internal hash table size.  This size is
  413. Xdefined in the program with the preprocessor variable "Table_size".  This
  414. Xconstant MUST be larger than the number of lines in the file /etc/passwd.
  415. XIt is advisable that this number be about twice the number of lines, and
  416. Xthat it be a prime number (since it dictates the size of the hash table).
  417. XMake sure this is checked before compilation.  Its definition exists in
  418. Xthe file "top.local.h", but it is also settable in the Makefile.
  419. X
  420. XSeveral other things are set in "top.local.h", including the file names
  421. Xused for certain system files ("/vmunix", "/dev/kmem", etc.).  Although I
  422. Xdon't expect those to vary much, they are put there for convenience.
  423. XAnother parameter in this file is "Nominal_TOPN".  This will be discussed
  424. Xin the next paragraph.
  425. X
  426. XThere are two preprocessor variables that are defined at compile time by
  427. Xthe makefile.  These are "Default_TOPN" and "Default_DELAY".  Their values
  428. Xare the defaults used for the top number of processes to be displayed and
  429. Xthe number of seconds to delay between displays, respectively.  They are
  430. Xset by the Makefile variables "TOPN" and "DELAY", respectively.  These
  431. Xconstants are preset as follows:  TOPN=10, DELAY=5.  These can be
  432. Xoverridden by either changing the Makefile or by specifying the change on
  433. Xthe make command line (with something like "make TOPN=15").  Version 2 of
  434. Xtop understands an "infinite" value for the number of processes to
  435. Xdisplay.  Such a value indicates that top should display as much as will
  436. Xfill the screen.  To specify a Default_TOPN of infinity, set TOPN equal
  437. Xto -1.  Version 2 also understands the difference between an intelligent
  438. Xterminal and a dumb terminal (such as a hardcopy device or a file).
  439. XTypically, a default of infinity would not be desirable on a dumb
  440. Xterminal, so the value of "Nominal_TOPN" is used when (1) Default_TOPN is
  441. Xinfinity and (2) the output device is a dumb terminal or a file.  The
  442. Xvalue for this preprocessor variable is set in "top.local.h" and can also
  443. Xbe set from the "make" command line.  In the distribution, it is set to 18.
  444. X
  445. XBy default, the makefile will make a "top" for one of the following
  446. Xsystems:  Berkeley 4.2, Sun Unix (version 1.1 and higher), and Pyramid
  447. XUnix.  Previous versions of top fully supported Berkeley 4.1 Unix.  This
  448. Xsupport has waned in version 2, and is not guaranteed to even work.  If
  449. Xyou really must give it a try, you can change the makefile variable
  450. X"CFLAGS" to make a 4.1 "top".  Instructions for doing this can be found in
  451. X"Makefile".
  452. X
  453. XThe file "bzero.c" contains a function that will zero a block of memory on
  454. Xa VAX.  This is only needed for Berkeley 4.1, since 4.2 has a bzero
  455. Xdefined in the C run time library.  If you are strange enough to be
  456. Xrunning 4.1 on something besides a VAX, you will have to replace this
  457. Xroutine with one that will work on your machine.  If you don't know a
  458. Xquick way to do it, then writing a simple loop will suffice.  "Bzero"
  459. Xtakes two arguments:  a pointer to the buffer to zero, and the number of
  460. Xbytes to zero.
  461. X
  462. XThere are also several parameters in the makefile that control
  463. Xinstallation.  These should be altered to suit the desires and needs of
  464. Xindividual sites.
  465. X
  466. XVersion 2.0 still only supports standard 4.2 and Sun and Pyramid
  467. Xarchitectures.  I attempted to add sufficient changes to make top work on
  468. Xa Masscomp, but found the number of required changes to be overwhelming.
  469. XFeel free to alter top to make it run on whatever funny architecture you
  470. Xhave.  I also encourage you to send those changes back to me at the
  471. Xaddress below.  But, if the number of changes is high, I will be reluctant
  472. Xto include the changes in the next version of top.  As an example, there
  473. Xwere only 10 modifications required for the Sun version (and all changes
  474. Xwere trivial), and just 4 changes were needed for the Pyramid.
  475. X
  476. XIf you make any kind of change to "top" that you feel would be beneficial
  477. Xto others who use this program, or if you find and fix a bug, please send
  478. Xme the change.
  479. X
  480. XEnjoy!
  481. X
  482. X                                William LeFebvre
  483. X                Department of Computer Science
  484. X                Rice University
  485. X                                ARPANet address: <phil@Rice.edu>
  486. X
  487. X                U.S. Mail address:
  488. X                    William LeFebvre
  489. X                    P.O. Box 1892
  490. X                    Department of Computer Science
  491. X                    Houston, TX  77251
  492. END_OF_README
  493. if test 5259 -ne `wc -c <README`; then
  494.     echo shar: \"README\" unpacked with wrong size!
  495. fi
  496. # end of overwriting check
  497. fi
  498. if test -f boolean.h -a "${1}" != "-c" ; then 
  499.   echo shar: Will not over-write existing file \"boolean.h\"
  500. else
  501. echo shar: Extracting \"boolean.h\" \(125 characters\)
  502. sed "s/^X//" >boolean.h <<'END_OF_boolean.h'
  503. X/* My favorite names for boolean values */
  504. X#define  No    0
  505. X#define  Yes    1
  506. X#define  Maybe    2        /* tri-state boolean, actually */
  507. X
  508. END_OF_boolean.h
  509. if test 125 -ne `wc -c <boolean.h`; then
  510.     echo shar: \"boolean.h\" unpacked with wrong size!
  511. fi
  512. # end of overwriting check
  513. fi
  514. if test -f bzero.c -a "${1}" != "-c" ; then 
  515.   echo shar: Will not over-write existing file \"bzero.c\"
  516. else
  517. echo shar: Extracting \"bzero.c\" \(789 characters\)
  518. sed "s/^X//" >bzero.c <<'END_OF_bzero.c'
  519. X/*
  520. X *  Fast, sleazy, and ugly zero function.
  521. X *
  522. X *  Note that this will only work on a VAX, but it is real easy to write a
  523. X *  similar function for whatever machine you may need.  If nothing else,
  524. X *  just a simple loop in C will suffice.
  525. X *
  526. X *  Dave Johnson, Rice University.
  527. X *
  528. X *  Enhanced by William LeFebvre of Rice University to handle zeroing more
  529. X *  than 64K.
  530. X */
  531. X
  532. X# define   K    1024
  533. X
  534. X/*
  535. X *  bzero(memory, amount) - set "amount" bytes starting at "memory" to the
  536. X *                value 0.
  537. X */
  538. X
  539. Xbzero(memory, amount)
  540. X
  541. Xchar *memory;
  542. Xint  amount;
  543. X
  544. X{
  545. X    while (amount >= 64*K)
  546. X    {
  547. X    _bzero64(memory, 64*K-1);
  548. X    memory += 64*K-1;
  549. X    amount -= 64*K-1;
  550. X    }
  551. X    _bzero64(memory, amount);
  552. X}
  553. X
  554. X_bzero64(memory, amount)
  555. X
  556. Xchar *memory;
  557. Xint  amount;
  558. X
  559. X{
  560. X    asm("    movc5    $0, (sp), $0, 8(ap), *4(ap)");
  561. X}
  562. END_OF_bzero.c
  563. if test 789 -ne `wc -c <bzero.c`; then
  564.     echo shar: \"bzero.c\" unpacked with wrong size!
  565. fi
  566. # end of overwriting check
  567. fi
  568. if test -f commands.c -a "${1}" != "-c" ; then 
  569.   echo shar: Will not over-write existing file \"commands.c\"
  570. else
  571. echo shar: Extracting \"commands.c\" \(8806 characters\)
  572. sed "s/^X//" >commands.c <<'END_OF_commands.c'
  573. X/*
  574. X *  Top users display for Berkeley Unix
  575. X *
  576. X *  This file contains the routines that implement some of the interactive
  577. X *  mode commands.  Note that some of the commands are implemented in-line
  578. X *  in "main".  This is necessary because they change the global state of
  579. X *  "top" (i.e.:  changing the number of processes to display).
  580. X */
  581. X
  582. X#include <stdio.h>
  583. X#include <ctype.h>
  584. X#include <signal.h>
  585. X#include <sys/time.h>
  586. X#include <sys/resource.h>
  587. X#include "sigdesc.h"        /* generated automatically */
  588. X#include "boolean.h"
  589. X
  590. Xextern int  errno;
  591. Xextern int  sys_nerr;
  592. Xextern char *sys_errlist[];
  593. X
  594. Xextern char *copyright;
  595. X
  596. Xint err_compar();
  597. Xchar *err_string();
  598. Xchar *index();
  599. X
  600. X/*
  601. X *  show_help() - display the help screen; invoked in response to
  602. X *        either 'h' or '?'.
  603. X */
  604. X
  605. Xshow_help()
  606. X
  607. X{
  608. X    fputs(copyright, stdout);
  609. X    fputs("\n\n\
  610. XA top users display for Unix\n\
  611. X\n\
  612. XThese single-character commands are available:\n\
  613. X\n\
  614. X^L      - redraw screen\n\
  615. Xq       - quit\n\
  616. Xh or ?  - help; show this text\n\
  617. Xd       - change number of displays to show\n\
  618. Xe       - list errors generated by last \"kill\" or \"renice\" command\n\
  619. Xk       - kill processes; send a signal to a list of processes\n\
  620. Xn or #  - change number of processes to display\n\
  621. Xr       - renice a process\n\
  622. Xs       - change number of seconds to delay between updates\n\
  623. X\n\
  624. X\n", stdout);
  625. X}
  626. X
  627. X/*
  628. X *  Utility routines that help with some of the commands.
  629. X */
  630. X
  631. Xchar *next_field(str)
  632. X
  633. Xregister char *str;
  634. X
  635. X{
  636. X    register char *temp;
  637. X
  638. X    if ((str = index(str, ' ')) == NULL)
  639. X    {
  640. X    return(NULL);
  641. X    }
  642. X    *str = '\0';
  643. X    while (*++str == ' ') /* loop */;
  644. X    return(str);
  645. X}
  646. X
  647. Xscanint(str, intp)
  648. X
  649. Xchar *str;
  650. Xint  *intp;
  651. X
  652. X{
  653. X    register int val = 0;
  654. X    register char ch;
  655. X
  656. X    while ((ch = *str++) != '\0')
  657. X    {
  658. X    if (isdigit(ch))
  659. X    {
  660. X        val = val * 10 + (ch - '0');
  661. X    }
  662. X    else if (isspace(ch))
  663. X    {
  664. X        break;
  665. X    }
  666. X    else
  667. X    {
  668. X        return(-1);
  669. X    }
  670. X    }
  671. X    *intp = val;
  672. X    return(0);
  673. X}
  674. X
  675. X/*
  676. X *  Some of the commands make system calls that could generate errors.
  677. X *  These errors are collected up in an array of structures for later
  678. X *  contemplation and display.  Such routines return a string containing an
  679. X *  error message, or NULL if no errors occurred.  The next few routines are
  680. X *  for manipulating and displaying these errors.  We need an upper limit on
  681. X *  the number of errors, so we arbitrarily choose 20.
  682. X */
  683. X
  684. X#define ERRMAX 20
  685. X
  686. Xstruct errs        /* structure for a system-call error */
  687. X{
  688. X    int  errno;        /* value of errno (that is, the actual error) */
  689. X    char *arg;        /* argument that caused the error */
  690. X};
  691. X
  692. Xstatic struct errs errs[ERRMAX];
  693. Xstatic int errcnt;
  694. Xstatic char *err_toomany = " too many errors occurred";
  695. Xstatic char *err_listem = 
  696. X    " Many errors occurred.  Press `e' to display the list of errors.";
  697. X
  698. X/* These macros get used to reset and log the errors */
  699. X#define ERR_RESET   errcnt = 0
  700. X#define ERROR(p, e) if (errcnt >= ERRMAX) \
  701. X            { \
  702. X            return(err_toomany); \
  703. X            } \
  704. X            else \
  705. X            { \
  706. X            errs[errcnt].arg = (p); \
  707. X            errs[errcnt++].errno = (e); \
  708. X            }
  709. X
  710. X/*
  711. X *  err_string() - return an appropriate error string.  This is what the
  712. X *    command will return for displaying.  If no errors were logged, then
  713. X *    return NULL.  The maximum length of the error string is defined by
  714. X *    "STRMAX".
  715. X */
  716. X
  717. X#define STRMAX 80
  718. X
  719. Xchar *err_string()
  720. X
  721. X{
  722. X    register char *ptr;
  723. X    register struct errs *errp;
  724. X    register int  cnt = 0;
  725. X    register int  first = Yes;
  726. X    register int  currerr = -1;
  727. X    int stringlen;        /* characters still available in "string" */
  728. X    char string[STRMAX];
  729. X
  730. X    /* if there are no errors, return NULL */
  731. X    if (errcnt == 0)
  732. X    {
  733. X    return(NULL);
  734. X    }
  735. X
  736. X    /* sort the errors */
  737. X    qsort(errs, errcnt, sizeof(struct errs), err_compar);
  738. X
  739. X    /* need a space at the from of the error string */
  740. X    string[0] = ' ';
  741. X    string[1] = '\0';
  742. X    stringlen = STRMAX - 2;
  743. X
  744. X    /* loop thru the sorted list, building an error string */
  745. X    ptr = string;
  746. X    while (cnt < errcnt)
  747. X    {
  748. X    errp = &(errs[cnt++]);
  749. X    if (errp->errno != currerr)
  750. X    {
  751. X        if (currerr != -1)
  752. X        {
  753. X        if ((stringlen = str_adderr(string, stringlen, currerr)) < 2)
  754. X        {
  755. X            return(err_listem);
  756. X        }
  757. X        strcat(string, "; ");        /* we know there's more */
  758. X        }
  759. X        currerr = errp->errno;
  760. X        first = Yes;
  761. X    }
  762. X    if ((stringlen = str_addarg(string, stringlen, errp->arg, first)) ==0)
  763. X    {
  764. X        return(err_listem);
  765. X    }
  766. X    first = No;
  767. X    }
  768. X
  769. X    /* add final message */
  770. X    stringlen = str_adderr(string, stringlen, currerr);
  771. X
  772. X    /* return the error string */
  773. X    return(stringlen == 0 ? err_listem : string);
  774. X}
  775. X
  776. X/*
  777. X *  str_adderr(str, len, err) - add an explanation of error "err" to
  778. X *    the string "str".
  779. X */
  780. X
  781. Xstr_adderr(str, len, err)
  782. X
  783. Xchar *str;
  784. Xint len;
  785. Xint err;
  786. X
  787. X{
  788. X    register char *msg;
  789. X    register int  msglen;
  790. X
  791. X    msg = err == 0 ? "Not a number" : sys_errlist[err];
  792. X    msglen = strlen(msg) + 2;
  793. X    if (len <= msglen)
  794. X    {
  795. X    return(0);
  796. X    }
  797. X    strcat(str, ": ");
  798. X    strcat(str, msg);
  799. X    return(len - msglen);
  800. X}
  801. X
  802. X/*
  803. X *  str_addarg(str, len, arg, first) - add the string argument "arg" to
  804. X *    the string "str".  This is the first in the group when "first"
  805. X *    is set (indicating that a comma should NOT be added to the front).
  806. X */
  807. X
  808. Xstr_addarg(str, len, arg, first)
  809. X
  810. Xchar *str;
  811. Xint  len;
  812. Xchar *arg;
  813. Xint  first;
  814. X
  815. X{
  816. X    register int arglen;
  817. X
  818. X    arglen = strlen(arg);
  819. X    if (!first)
  820. X    {
  821. X    arglen += 2;
  822. X    }
  823. X    if (len <= arglen)
  824. X    {
  825. X    return(0);
  826. X    }
  827. X    if (!first)
  828. X    {
  829. X    strcat(str, ", ");
  830. X    }
  831. X    strcat(str, arg);
  832. X    return(len - arglen);
  833. X}
  834. X
  835. X/*
  836. X *  err_compar(p1, p2) - comparison routine used by "qsort"
  837. X *    for sorting errors.
  838. X */
  839. X
  840. Xerr_compar(p1, p2)
  841. X
  842. Xregister struct errs *p1, *p2;
  843. X
  844. X{
  845. X    register int result;
  846. X
  847. X    if ((result = p1->errno - p2->errno) == 0)
  848. X    {
  849. X    return(strcmp(p1->arg, p2->arg));
  850. X    }
  851. X    return(result);
  852. X}
  853. X
  854. X/*
  855. X *  error_count() - return the number of errors currently logged.
  856. X */
  857. X
  858. Xerror_count()
  859. X
  860. X{
  861. X    return(errcnt);
  862. X}
  863. X
  864. X/*
  865. X *  show_errors() - display on stdout the current log of errors.
  866. X */
  867. X
  868. Xshow_errors()
  869. X
  870. X{
  871. X    register int cnt = 0;
  872. X    register struct errs *errp = errs;
  873. X
  874. X    printf("%d error%s:\n\n", errcnt, errcnt == 1 ? "" : "s");
  875. X    while (cnt++ < errcnt)
  876. X    {
  877. X    printf("%5s: %s\n", errp->arg,
  878. X        errp->errno == 0 ? "Not a number" : sys_errlist[errp->errno]);
  879. X    errp++;
  880. X    }
  881. X}
  882. X
  883. X/*
  884. X *  kill_procs(str) - send signals to processes, much like the "kill"
  885. X *        command does; invoked in response to 'k'.
  886. X */
  887. X
  888. Xchar *kill_procs(str)
  889. X
  890. Xchar *str;
  891. X
  892. X{
  893. X    register char *nptr;
  894. X    register char *optr;
  895. X    int signum = SIGTERM;    /* default */
  896. X    int procnum;
  897. X    char badnum = 0;
  898. X    struct sigdesc *sigp;
  899. X
  900. X    ERR_RESET;
  901. X    if (str[0] == '-')
  902. X    {
  903. X    /* explicit signal specified */
  904. X    if ((optr = nptr = next_field(str)) == NULL)
  905. X    {
  906. X        return(" kill: no processes specified");
  907. X    }
  908. X
  909. X    if (isdigit(str[1]))
  910. X    {
  911. X        scanint(str + 1, &signum);
  912. X        if (signum <= 0 || signum >= NSIG)
  913. X        {
  914. X        return(" invalid signal number");
  915. X        }
  916. X    }
  917. X    else 
  918. X    {
  919. X        /* translate the name into a number */
  920. X        for (sigp = sigdesc; sigp->name != NULL; sigp++)
  921. X        {
  922. X        if (strcmp(sigp->name, str + 1) == 0)
  923. X        {
  924. X            signum = sigp->number;
  925. X            break;
  926. X        }
  927. X        }
  928. X
  929. X        /* was it ever found */
  930. X        if (sigp->name == NULL)
  931. X        {
  932. X        return(" bad signal name");
  933. X        }
  934. X    }
  935. X    /* put the new pointer in place */
  936. X    str = nptr;
  937. X    }
  938. X
  939. X    /* loop thru the string, killing processes */
  940. X    do
  941. X    {
  942. X    if (scanint(str, &procnum) == -1)
  943. X    {
  944. X        ERROR(str, 0);
  945. X    }
  946. X    else if (kill(procnum, signum) == -1)
  947. X    {
  948. X        /* chalk up an error */
  949. X        ERROR(str, errno);
  950. X    }
  951. X    } while ((str = next_field(str)) != NULL);
  952. X
  953. X    /* return appropriate error string */
  954. X    return(err_string());
  955. X}
  956. X
  957. X/*
  958. X *  renice_procs(str) - change the "nice" of processes, much like the
  959. X *        "renice" command does; invoked in response to 'r'.
  960. X */
  961. X
  962. Xchar *renice_procs(str)
  963. X
  964. Xchar *str;
  965. X
  966. X{
  967. X    register char negate;
  968. X    int prio;
  969. X    int procnum;
  970. X
  971. X    ERR_RESET;
  972. X
  973. X    /* allow for negative priority values */
  974. X    if ((negate = *str == '-'))
  975. X    {
  976. X    /* move past the minus sign */
  977. X    str++;
  978. X    }
  979. X
  980. X    /* use procnum as a temporary holding place and get the number */
  981. X    procnum = scanint(str, &prio);
  982. X
  983. X    /* negate if necessary */
  984. X    if (negate)
  985. X    {
  986. X    prio = -prio;
  987. X    }
  988. X
  989. X    /* check for validity */
  990. X    if (procnum == -1 || prio <= PRIO_MIN || prio >= PRIO_MAX)
  991. X    {
  992. X    return(" bad priority value");
  993. X    }
  994. X
  995. X    /* move to the first process number */
  996. X    if ((str = next_field(str)) == NULL)
  997. X    {
  998. X    return(" no processes specified");
  999. X    }
  1000. X
  1001. X    /* loop thru the process numbers, renicing each one */
  1002. X    do
  1003. X    {
  1004. X    if (scanint(str, &procnum) == -1)
  1005. X    {
  1006. X        ERROR(str, 0);
  1007. X    }
  1008. X    else if (setpriority(PRIO_PROCESS, procnum, prio) == -1)
  1009. X    {
  1010. X        ERROR(str, errno);
  1011. X    }
  1012. X    } while ((str = next_field(str)) != NULL);
  1013. X
  1014. X    /* return appropriate error string */
  1015. X    return(err_string());
  1016. X}
  1017. X
  1018. END_OF_commands.c
  1019. if test 8806 -ne `wc -c <commands.c`; then
  1020.     echo shar: \"commands.c\" unpacked with wrong size!
  1021. fi
  1022. # end of overwriting check
  1023. fi
  1024. if test -f getopt.c -a "${1}" != "-c" ; then 
  1025.   echo shar: Will not over-write existing file \"getopt.c\"
  1026. else
  1027. echo shar: Extracting \"getopt.c\" \(1259 characters\)
  1028. sed "s/^X//" >getopt.c <<'END_OF_getopt.c'
  1029. X/*LINTLIBRARY*/
  1030. X#define NULL    0
  1031. X#define EOF    (-1)
  1032. X#define ERR(s, c)    if(opterr){\
  1033. X    extern int strlen(), write();\
  1034. X    char errbuf[2];\
  1035. X    errbuf[0] = c; errbuf[1] = '\n';\
  1036. X    (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
  1037. X    (void) write(2, s, (unsigned)strlen(s));\
  1038. X    (void) write(2, errbuf, 2);}
  1039. X
  1040. X#define strchr index
  1041. X
  1042. Xextern int strcmp();
  1043. Xextern char *strchr();
  1044. X
  1045. Xint    opterr = 1;
  1046. Xint    optind = 1;
  1047. Xint    optopt;
  1048. Xchar    *optarg;
  1049. X
  1050. Xint
  1051. Xgetopt(argc, argv, opts)
  1052. Xint    argc;
  1053. Xchar    **argv, *opts;
  1054. X{
  1055. X    static int sp = 1;
  1056. X    register int c;
  1057. X    register char *cp;
  1058. X
  1059. X    if(sp == 1)
  1060. X        if(optind >= argc ||
  1061. X           argv[optind][0] != '-' || argv[optind][1] == '\0')
  1062. X            return(EOF);
  1063. X        else if(strcmp(argv[optind], "--") == NULL) {
  1064. X            optind++;
  1065. X            return(EOF);
  1066. X        }
  1067. X    optopt = c = argv[optind][sp];
  1068. X    if(c == ':' || (cp=strchr(opts, c)) == NULL) {
  1069. X        ERR(": unknown option, -", c);
  1070. X        if(argv[optind][++sp] == '\0') {
  1071. X            optind++;
  1072. X            sp = 1;
  1073. X        }
  1074. X        return('?');
  1075. X    }
  1076. X    if(*++cp == ':') {
  1077. X        if(argv[optind][sp+1] != '\0')
  1078. X            optarg = &argv[optind++][sp+1];
  1079. X        else if(++optind >= argc) {
  1080. X            ERR(": argument missing for -", c);
  1081. X            sp = 1;
  1082. X            return('?');
  1083. X        } else
  1084. X            optarg = argv[optind++];
  1085. X        sp = 1;
  1086. X    } else {
  1087. X        if(argv[optind][++sp] == '\0') {
  1088. X            sp = 1;
  1089. X            optind++;
  1090. X        }
  1091. X        optarg = NULL;
  1092. X    }
  1093. X    return(c);
  1094. X}
  1095. END_OF_getopt.c
  1096. if test 1259 -ne `wc -c <getopt.c`; then
  1097.     echo shar: \"getopt.c\" unpacked with wrong size!
  1098. fi
  1099. # end of overwriting check
  1100. fi
  1101. if test -f kernel.c -a "${1}" != "-c" ; then 
  1102.   echo shar: Will not over-write existing file \"kernel.c\"
  1103. else
  1104. echo shar: Extracting \"kernel.c\" \(3693 characters\)
  1105. sed "s/^X//" >kernel.c <<'END_OF_kernel.c'
  1106. X/*
  1107. X *  Top - a top users display for Berkeley Unix
  1108. X *  
  1109. X *  This file contains all the routines that retrieve values from
  1110. X *  kernel and user memory.
  1111. X */
  1112. X
  1113. X#include <stdio.h>
  1114. X#if defined(FOUR_ONE) || defined(pyr)
  1115. X#include <sys/pte.h>
  1116. X#else
  1117. X#include <machine/pte.h>
  1118. X#endif
  1119. X#include <sys/param.h>
  1120. X#include <sys/dir.h>
  1121. X#include <sys/user.h>
  1122. X#if defined(scs)
  1123. X# define FLOAT        /* for pcrcpu in proc.h */
  1124. X# include <sys/vm.h>    /* for struct spt */
  1125. X#endif
  1126. X#include <sys/proc.h>
  1127. X
  1128. X#include "top.local.h"
  1129. X
  1130. X/* useful externals */
  1131. Xextern int errno;
  1132. Xextern char *sys_errlist[];
  1133. X
  1134. Xstatic int kmem = -1;
  1135. Xstatic int mem = -1;
  1136. X
  1137. Xinit_kernel()
  1138. X{
  1139. X    /* open kmem and mem */
  1140. X    if ((kmem = open(KMEM, 0)) < 0)
  1141. X    {
  1142. X    perror(KMEM);
  1143. X    exit(20);
  1144. X    }
  1145. X    if ((mem = open(MEM, 0)) < 0)
  1146. X    {
  1147. X    perror(MEM);
  1148. X    exit(21);
  1149. X    }
  1150. X}
  1151. X
  1152. X#if !defined(scs)
  1153. X
  1154. X/*
  1155. X *  getu(p, u) - get the user structure for the process whose proc structure
  1156. X *    is pointed to by p.  The user structure is put in the buffer pointed
  1157. X *    to by u.  Return 0 if successful, -1 on failure (such as the process
  1158. X *    being swapped out).
  1159. X */
  1160. X
  1161. Xgetu(p, u)
  1162. X
  1163. Xregister struct proc *p;
  1164. Xstruct user *u;
  1165. X
  1166. X{
  1167. X    struct pte uptes[UPAGES];
  1168. X    register caddr_t upage;
  1169. X    register struct pte *pte;
  1170. X    register nbytes, n;
  1171. X
  1172. X    /*
  1173. X     *  Check if the process is currently loaded or swapped out.  The way we
  1174. X     *  get the u area is totally different for the two cases.  For this
  1175. X     *  application, we just don't bother if the process is swapped out.
  1176. X     */
  1177. X    if (!(p->p_flag & SLOAD))
  1178. X    {
  1179. X    return(-1);
  1180. X    }
  1181. X
  1182. X    /*
  1183. X     *  Process is currently in memory, we hope!
  1184. X     */
  1185. X    if (!getkval(p->p_addr, uptes, sizeof(uptes), "!p->p_addr"))
  1186. X    {
  1187. X    /* we can't seem to get to it, so pretend it's swapped out */
  1188. X    return(-1);
  1189. X    } 
  1190. X    upage = (caddr_t)u;
  1191. X    pte = uptes;
  1192. X    for (nbytes = sizeof(struct user); nbytes > 0; nbytes -= NBPG)
  1193. X    {
  1194. X        lseek(mem, pte++->pg_pfnum * NBPG, 0);
  1195. X    n = MIN(nbytes, NBPG);
  1196. X    if (read(mem, upage, n) != n)
  1197. X    {
  1198. X        /* we can't seem to get to it, so pretend it's swapped out */
  1199. X        return(-1);
  1200. X    }
  1201. X    upage += n;
  1202. X    }
  1203. X    return(0);
  1204. X}
  1205. X#endif !scs
  1206. X
  1207. X/*
  1208. X *  getkval(offset, ptr, size, refstr) - get a value out of the kernel.
  1209. X *    "offset" is the byte offset into the kernel for the desired value,
  1210. X *      "ptr" points to a buffer into which the value is retrieved,
  1211. X *      "size" is the size of the buffer (and the object to retrieve),
  1212. X *      "refstr" is a reference string used when printing error meessages,
  1213. X *        if "refstr" starts with a '!', then a failure on read will not
  1214. X *          be fatal (this may seem like a silly way to do things, but I
  1215. X *          really didn't want the overhead of another argument).
  1216. X *      
  1217. X */
  1218. X
  1219. Xgetkval(offset, ptr, size, refstr)
  1220. X
  1221. Xlong offset;
  1222. Xint *ptr;
  1223. Xint size;
  1224. Xchar *refstr;
  1225. X
  1226. X{
  1227. X    if (lseek(kmem, offset, 0) == -1)
  1228. X    {
  1229. X    if (*refstr == '!')
  1230. X    {
  1231. X        refstr++;
  1232. X    }
  1233. X    fprintf(stderr, "%s: lseek to %s: %s\n",
  1234. X        KMEM, refstr, sys_errlist[errno]);
  1235. X    quit(22);
  1236. X    }
  1237. X    if (read(kmem, ptr, size) == -1)
  1238. X    {
  1239. X    if (*refstr == '!')
  1240. X    {
  1241. X        /* we lost the race with the kernel, process isn't in memory */
  1242. X        return(0);
  1243. X    } 
  1244. X    else 
  1245. X    {
  1246. X        fprintf(stderr, "%s: reading %s: %s\n",
  1247. X        KMEM, refstr, sys_errlist[errno]);
  1248. X        quit(23);
  1249. X    }
  1250. X    }
  1251. X    return(1);
  1252. X}
  1253. X
  1254. X#if defined(scs)
  1255. Xvoid
  1256. Xget_spt(spti, sptp)
  1257. X    int        spti;
  1258. X    struct spt    *sptp;
  1259. X{
  1260. X    extern struct spt    *spt;        /* defined in top.c */
  1261. X
  1262. X    /* Let's get tricky, shall we?  *spt is a pointer in kernel space;
  1263. X     * we can use it in a getkval() call, but we can't dereference it
  1264. X     * directly.  However, C's pointer arithmetic will still work, even
  1265. X     * though we aren't going to use the pointer as a pointer...
  1266. X     */
  1267. X
  1268. X    getkval(spt + spti, sptp, sizeof(struct spt), "spt");
  1269. X}
  1270. X#endif scs
  1271. END_OF_kernel.c
  1272. if test 3693 -ne `wc -c <kernel.c`; then
  1273.     echo shar: \"kernel.c\" unpacked with wrong size!
  1274. fi
  1275. # end of overwriting check
  1276. fi
  1277. if test -f layout.h -a "${1}" != "-c" ; then 
  1278.   echo shar: Will not over-write existing file \"layout.h\"
  1279. else
  1280. echo shar: Extracting \"layout.h\" \(845 characters\)
  1281. sed "s/^X//" >layout.h <<'END_OF_layout.h'
  1282. X/*
  1283. X *  Top - a top users display for Berkeley Unix
  1284. X *
  1285. X *  This file defines the locations on tne screen for various parts of the
  1286. X *  display.  These definitions are used by the routines in "display.c" for
  1287. X *  cursor addressing.
  1288. X */
  1289. X
  1290. X#define  x_lastpid    10
  1291. X#define  y_lastpid    0
  1292. X#define  x_loadave    33
  1293. X#define  y_loadave    0
  1294. X#define  x_procstate    0
  1295. X#define  y_procstate    1
  1296. X#define  x_brkdn    14
  1297. X#define  y_brkdn    1
  1298. X#define  x_realmem    8
  1299. X#define  x_virtmem    28
  1300. X#define  x_free        51
  1301. X#define  y_mem        3
  1302. X#define  x_header    0
  1303. X#define  y_header    5
  1304. X#define  x_idlecursor    0
  1305. X#define  y_idlecursor    4
  1306. X#define  y_procs    6
  1307. X#define  x_p_pid    0
  1308. X#define  x_p_user    6
  1309. X#define  x_p_pri    15
  1310. X#define  x_p_nice    20
  1311. X#define  x_p_size    25
  1312. X#define  x_p_res    31
  1313. X#define  x_p_state    37
  1314. X#define  x_p_time    43
  1315. X#define  x_p_wcpu    50
  1316. X#define  x_p_cpu    57
  1317. X#define  x_p_command    64
  1318. X
  1319. X#define  y_cpustates    2
  1320. END_OF_layout.h
  1321. if test 845 -ne `wc -c <layout.h`; then
  1322.     echo shar: \"layout.h\" unpacked with wrong size!
  1323. fi
  1324. # end of overwriting check
  1325. fi
  1326. if test -f screen.c -a "${1}" != "-c" ; then 
  1327.   echo shar: Will not over-write existing file \"screen.c\"
  1328. else
  1329. echo shar: Extracting \"screen.c\" \(4697 characters\)
  1330. sed "s/^X//" >screen.c <<'END_OF_screen.c'
  1331. X/*
  1332. X *  Top - a top users display for Berkeley Unix
  1333. X *
  1334. X *  This file contains the routines that interface to termcap and stty/gtty.
  1335. X *
  1336. X *  Paul Vixie, February 1987: converted to use ioctl() instead of stty/gtty.
  1337. X */
  1338. X
  1339. X#include <stdio.h>
  1340. X#include <sgtty.h>
  1341. X#include "screen.h"
  1342. X#include "boolean.h"
  1343. X
  1344. Xextern char *myname;
  1345. X
  1346. Xint putstdout();
  1347. X
  1348. Xint  scrolls;
  1349. Xint  hardcopy;
  1350. Xint  screen_length;
  1351. Xint  screen_width;
  1352. Xchar ch_erase;
  1353. Xchar ch_kill;
  1354. Xchar smart_terminal;
  1355. Xchar PC;
  1356. Xchar *tgetstr();
  1357. Xchar *tgoto();
  1358. Xchar termcap_buf[1024];
  1359. Xchar init_buf[1024];
  1360. Xchar string_buffer[1024];
  1361. Xchar home[15];
  1362. Xchar lower_left[15];
  1363. Xchar *clear_line;
  1364. Xchar *clear_screen;
  1365. Xchar *cursor_motion;
  1366. Xchar *start_standout;
  1367. Xchar *end_standout;
  1368. Xchar *terminal_init;
  1369. Xchar *terminal_end;
  1370. Xshort ospeed;
  1371. X
  1372. Xstatic struct sgttyb old_settings;
  1373. Xstatic struct sgttyb new_settings;
  1374. Xstatic char is_a_terminal = No;
  1375. X
  1376. X#define    STDIN    0
  1377. X#define    STDOUT    1
  1378. X#define    STDERR    2
  1379. X
  1380. Xinit_termcap()
  1381. X
  1382. X{
  1383. X    char *bufptr;
  1384. X    char *PCptr;
  1385. X    char *term_name;
  1386. X    char *temp_ptr;
  1387. X    char *getenv();
  1388. X    int status;
  1389. X
  1390. X    /* assume we have a smart terminal until proven otherwise */
  1391. X    smart_terminal = Yes;
  1392. X
  1393. X    /* now get terminal name and termcap entry */
  1394. X    term_name = getenv("TERM");
  1395. X    if ((status = tgetent(termcap_buf, term_name)) != 1)
  1396. X    {
  1397. X    if (status == -1)
  1398. X    {
  1399. X        fprintf(stderr, "%s: can't open termcap file\n", myname);
  1400. X    }
  1401. X    else
  1402. X    {
  1403. X        fprintf(stderr, "%s: no termcap entry for a `%s' terminal\n",
  1404. X            myname, getenv("TERM"));
  1405. X    }
  1406. X
  1407. X    /* pretend it's dumb and proceed */
  1408. X    smart_terminal = No;
  1409. X    return;
  1410. X    }
  1411. X
  1412. X    /* these immediately indicate a very stupid terminal */
  1413. X    if (tgetflag("hc") || tgetflag("os"))
  1414. X    {
  1415. X    smart_terminal = No;
  1416. X    return;
  1417. X    }
  1418. X
  1419. X    /* set up common terminal capabilities */
  1420. X    if ((screen_length = tgetnum("li")) <= 0)
  1421. X    {
  1422. X    screen_length = smart_terminal = 0;
  1423. X    return;
  1424. X    }
  1425. X
  1426. X    /* screen_width is a little different */
  1427. X    if ((screen_width = tgetnum("co")) == -1)
  1428. X    {
  1429. X    screen_width = 79;
  1430. X    }
  1431. X    else
  1432. X    {
  1433. X    screen_width -= 1;
  1434. X    }
  1435. X
  1436. X    /* initialize the pointer into the termcap string buffer */
  1437. X    bufptr = string_buffer;
  1438. X
  1439. X    /* get necessary capabilities */
  1440. X    if ((clear_line    = tgetstr("ce", &bufptr)) == NULL ||
  1441. X    (clear_screen  = tgetstr("cl", &bufptr)) == NULL ||
  1442. X    (cursor_motion = tgetstr("cm", &bufptr)) == NULL)
  1443. X    {
  1444. X    smart_terminal = No;
  1445. X    return;
  1446. X    }
  1447. X
  1448. X    /* get some more sophisticated stuff -- these are optional */
  1449. X    terminal_init  = tgetstr("ti", &bufptr);
  1450. X    terminal_end   = tgetstr("te", &bufptr);
  1451. X    start_standout = tgetstr("so", &bufptr);
  1452. X    end_standout   = tgetstr("se", &bufptr);
  1453. X
  1454. X    /* pad character */
  1455. X    PC = (PCptr = tgetstr("pc", &bufptr)) ? *PCptr : 0;
  1456. X
  1457. X    /* set convenience strings */
  1458. X    strcpy(home, tgoto(cursor_motion, 0, 0));
  1459. X    strcpy(lower_left, tgoto(cursor_motion, 0, screen_length - 1));
  1460. X
  1461. X    /* if stdout is not a terminal, pretend we are a dumb terminal */
  1462. X    if (-1 == ioctl(STDOUT, TIOCGETP, &old_settings))
  1463. X    {
  1464. X    smart_terminal = No;
  1465. X    }
  1466. X}
  1467. X
  1468. Xinit_screen()
  1469. X
  1470. X{
  1471. X    /* get the old settings for safe keeping */
  1472. X    if (0 == ioctl(STDOUT, TIOCGETP, &old_settings))
  1473. X    {
  1474. X    /* copy the settings so we can modify them */
  1475. X    new_settings = old_settings;
  1476. X
  1477. X    /* turn on CBREAK and turn off character echo and tab expansion */
  1478. X    new_settings.sg_flags |= CBREAK;
  1479. X    new_settings.sg_flags &= ~(ECHO|XTABS);
  1480. X    ioctl(STDOUT, TIOCSETP, &new_settings);
  1481. X
  1482. X    /* remember the erase and kill characters */
  1483. X    ch_erase = old_settings.sg_erase;
  1484. X    ch_kill  = old_settings.sg_kill;
  1485. X
  1486. X    /* remember that it really is a terminal */
  1487. X    is_a_terminal = Yes;
  1488. X
  1489. X    /* send the termcap initialization string */
  1490. X    putcap(terminal_init);
  1491. X    }
  1492. X    else
  1493. X    {
  1494. X    /* not a terminal at all---consider it dumb */
  1495. X    smart_terminal = No;
  1496. X    }
  1497. X}
  1498. X
  1499. Xend_screen()
  1500. X
  1501. X{
  1502. X    /* move to the lower left, clear the line and send "te" */
  1503. X    if (smart_terminal)
  1504. X    {
  1505. X    putcap(lower_left);
  1506. X    putcap(clear_line);
  1507. X    putcap(terminal_end);
  1508. X    }
  1509. X
  1510. X    /* if we have settings to reset, then do so */
  1511. X    if (is_a_terminal)
  1512. X    {
  1513. X    ioctl(STDOUT, TIOCSETP, &old_settings);
  1514. X    }
  1515. X}
  1516. X
  1517. Xreinit_screen()
  1518. X
  1519. X{
  1520. X    /* install our settings if it is a terminal */
  1521. X    if (is_a_terminal)
  1522. X    {
  1523. X    ioctl(STDOUT, TIOCSETP, &new_settings);
  1524. X    }
  1525. X
  1526. X    /* send init string */
  1527. X    if (smart_terminal)
  1528. X    {
  1529. X    putcap(terminal_init);
  1530. X    }
  1531. X}
  1532. X
  1533. Xstandout(fmt, a1, a2, a3)
  1534. X
  1535. Xchar *fmt;
  1536. Xint a1, a2, a3;
  1537. X
  1538. X{
  1539. X    if (smart_terminal)
  1540. X    {
  1541. X    putcap(start_standout);
  1542. X    printf(fmt, a1, a2, a3);
  1543. X    putcap(end_standout);
  1544. X    }
  1545. X    else
  1546. X    {
  1547. X    printf(fmt, a1, a2, a3);
  1548. X    }
  1549. X}
  1550. X
  1551. Xclear()
  1552. X
  1553. X{
  1554. X    if (smart_terminal)
  1555. X    {
  1556. X    putcap(clear_screen);
  1557. X    }
  1558. X}
  1559. X
  1560. X/* This has to be defined as a subroutine for tputs (instead of a macro) */
  1561. X
  1562. Xputstdout(ch)
  1563. X
  1564. Xchar ch;
  1565. X
  1566. X{
  1567. X    putchar(ch);
  1568. X}
  1569. X
  1570. END_OF_screen.c
  1571. if test 4697 -ne `wc -c <screen.c`; then
  1572.     echo shar: \"screen.c\" unpacked with wrong size!
  1573. fi
  1574. # end of overwriting check
  1575. fi
  1576. if test -f screen.h -a "${1}" != "-c" ; then 
  1577.   echo shar: Will not over-write existing file \"screen.h\"
  1578. else
  1579. echo shar: Extracting \"screen.h\" \(874 characters\)
  1580. sed "s/^X//" >screen.h <<'END_OF_screen.h'
  1581. X/*
  1582. X *  top - a top users display for Unix 4.2
  1583. X *
  1584. X *  This file contains all the definitions necessary to use the hand-written
  1585. X *  screen package in "screen.c"
  1586. X */
  1587. X
  1588. X#define TCputs(str)    tputs(str, 1, putstdout)
  1589. X#define putcap(str)    ((str) != NULL ? TCputs(str) : 0)
  1590. X#define Move_to(x, y)    TCputs(tgoto(cursor_motion, x, y))
  1591. X
  1592. Xextern char ch_erase;        /* set to the user's erase character */
  1593. Xextern char ch_kill;        /* set to the user's kill  character */
  1594. Xextern char smart_terminal;     /* set if the terminal has sufficient termcap
  1595. X                   capabilities for normal operation */
  1596. X
  1597. X/* These aresome termcap strings for use outside of "screen.c" */
  1598. Xextern char *cursor_motion;
  1599. Xextern char *clear_line;
  1600. X
  1601. X/* rows and columns on the screen according to termcap */
  1602. Xextern int  screen_length;
  1603. Xextern int  screen_width;
  1604. X
  1605. X/* a function that puts a single character on stdout */
  1606. Xint putstdout();
  1607. END_OF_screen.h
  1608. if test 874 -ne `wc -c <screen.h`; then
  1609.     echo shar: \"screen.h\" unpacked with wrong size!
  1610. fi
  1611. # end of overwriting check
  1612. fi
  1613. if test -f sigconv.awk -a "${1}" != "-c" ; then 
  1614.   echo shar: Will not over-write existing file \"sigconv.awk\"
  1615. else
  1616. echo shar: Extracting \"sigconv.awk\" \(439 characters\)
  1617. sed "s/^X//" >sigconv.awk <<'END_OF_sigconv.awk'
  1618. XBEGIN        {
  1619. X            print "/* This file was automatically generated */"
  1620. X            print "/* by the awk script \"sigconv.awk\".      */\n"
  1621. X            print "struct sigdesc {"
  1622. X            print "    char *name;"
  1623. X            print "    int  number;"
  1624. X            print "};\n"
  1625. X            print "struct sigdesc sigdesc[] = {"
  1626. X        }
  1627. X
  1628. X/^#define[ \t][ \t]*SIG[A-Z]/    {
  1629. X                    printf "    \"%s\",\t%2d,\n", \
  1630. X                    substr($2, 4), $3
  1631. X                }
  1632. X
  1633. XEND                {
  1634. X                    print "    NULL,\t 0\n};"
  1635. X                }
  1636. END_OF_sigconv.awk
  1637. if test 439 -ne `wc -c <sigconv.awk`; then
  1638.     echo shar: \"sigconv.awk\" unpacked with wrong size!
  1639. fi
  1640. # end of overwriting check
  1641. fi
  1642. if test -f sigdesc.h -a "${1}" != "-c" ; then 
  1643.   echo shar: Will not over-write existing file \"sigdesc.h\"
  1644. else
  1645. echo shar: Extracting \"sigdesc.h\" \(696 characters\)
  1646. sed "s/^X//" >sigdesc.h <<'END_OF_sigdesc.h'
  1647. X/* This file was automatically generated */
  1648. X/* by the awk script "sigconv.awk".      */
  1649. X
  1650. Xstruct sigdesc {
  1651. X    char *name;
  1652. X    int  number;
  1653. X};
  1654. X
  1655. Xstruct sigdesc sigdesc[] = {
  1656. X    "HUP",     1,
  1657. X    "INT",     2,
  1658. X    "QUIT",     3,
  1659. X    "ILL",     4,
  1660. X    "TRAP",     5,
  1661. X    "IOT",     6,
  1662. X    "EMT",     7,
  1663. X    "FPE",     8,
  1664. X    "KILL",     9,
  1665. X    "BUS",    10,
  1666. X    "SEGV",    11,
  1667. X    "SYS",    12,
  1668. X    "PIPE",    13,
  1669. X    "ALRM",    14,
  1670. X    "TERM",    15,
  1671. X    "URG",    16,
  1672. X    "STOP",    17,
  1673. X    "TSTP",    18,
  1674. X    "CONT",    19,
  1675. X    "CHLD",    20,
  1676. X    "TTIN",    21,
  1677. X    "TTOU",    22,
  1678. X    "IO",    23,
  1679. X    "XCPU",    24,
  1680. X    "XFSZ",    25,
  1681. X    "DVZ",    26,
  1682. X    "NMI",    27,
  1683. X    "WINCH",    28,
  1684. X    "PROF",    29,
  1685. X    "VTALRM",    30,
  1686. X    "USR1",    31,
  1687. X    "CATCHALL",    2000,
  1688. X    NULL,     0
  1689. X};
  1690. END_OF_sigdesc.h
  1691. if test 696 -ne `wc -c <sigdesc.h`; then
  1692.     echo shar: \"sigdesc.h\" unpacked with wrong size!
  1693. fi
  1694. # end of overwriting check
  1695. fi
  1696. if test -f top.h -a "${1}" != "-c" ; then 
  1697.   echo shar: Will not over-write existing file \"top.h\"
  1698. else
  1699. echo shar: Extracting \"top.h\" \(936 characters\)
  1700. sed "s/^X//" >top.h <<'END_OF_top.h'
  1701. X/*
  1702. X *  Top - a top users display for Berkeley Unix
  1703. X *
  1704. X *  General (global) definitions
  1705. X */
  1706. X
  1707. X/* Number of lines of header information on the standard screen */
  1708. X#define Header_lines    6
  1709. X
  1710. X/* Number of columns needed for display */
  1711. X#define Display_width    80
  1712. X
  1713. X/* Log base 2 of 1024 is 10 (2^10 == 1024) */
  1714. X#define LOG1024        10
  1715. X
  1716. X/* Convert clicks (kernel pages) to kbytes ... */
  1717. X/* If there is no PGSHIFT defined, assume it is 11 */
  1718. X/* Is this needed for compatability with some old flavor of 4.2 or 4.1? */
  1719. X#if defined(scs)
  1720. X    /* the s/375 <machine/param.h> has this as 9, but it's really 10 */
  1721. X# undef PGSHIFT
  1722. X# define PGSHIFT 10
  1723. X#endif scs
  1724. X
  1725. X#ifndef PGSHIFT
  1726. X# define pagetok(size)    ((size) << 1)
  1727. X#else
  1728. X# if PGSHIFT>10
  1729. X#  define pagetok(size)    ((size) << (PGSHIFT - LOG1024))
  1730. X# else
  1731. X#  define pagetok(size)    ((size) >> (LOG1024 - PGSHIFT))
  1732. X# endif
  1733. X#endif
  1734. X
  1735. Xextern double logcpu;
  1736. X
  1737. Xdouble log();
  1738. Xdouble exp();
  1739. X
  1740. Xextern char (* screenbuf)[Display_width];
  1741. END_OF_top.h
  1742. if test 936 -ne `wc -c <top.h`; then
  1743.     echo shar: \"top.h\" unpacked with wrong size!
  1744. fi
  1745. # end of overwriting check
  1746. fi
  1747. if test -f top.local.h -a "${1}" != "-c" ; then 
  1748.   echo shar: Will not over-write existing file \"top.local.h\"
  1749. else
  1750. echo shar: Extracting \"top.local.h\" \(1208 characters\)
  1751. sed "s/^X//" >top.local.h <<'END_OF_top.local.h'
  1752. X/*
  1753. X *  Top - a top users display for Berkeley Unix
  1754. X *
  1755. X *  Definitions for things that might vary between installations.
  1756. X */
  1757. X
  1758. X/*
  1759. X *  "Table_size" defines the size of the hash tables used to map uid to
  1760. X *  username.  The number of users in /etc/passwd CANNOT be greater than
  1761. X *  this number.  If the error message "table overflow: too many users"
  1762. X *  is printed by top, then "Table_size" needs to be increased.  Things will
  1763. X *  work best if the number is a prime number that is about twice the number
  1764. X *  of lines in /etc/passwd.
  1765. X */
  1766. X#ifndef Table_size
  1767. X#define Table_size    57
  1768. X#endif
  1769. X
  1770. X/*
  1771. X *  "Nominal_TOPN" is used as the default TOPN when Default_TOPN is Infinity
  1772. X *  and the output is a dumb terminal.  If we didn't do this, then
  1773. X *  installations who use a default TOPN of Infinity will get every
  1774. X *  process in the system when running top on a dumb terminal (or redirected
  1775. X *  to a file).  Note that Nominal_TOPN is a default:  it can still be
  1776. X *  overridden on the command line, even with the value "infinity".
  1777. X */
  1778. X#ifndef Nominal_TOPN
  1779. X#define Nominal_TOPN    18
  1780. X#endif
  1781. X
  1782. X/*
  1783. X *  File name for the system image and the memory devices.
  1784. X */
  1785. X#define VMUNIX    "/vmunix"
  1786. X#define KMEM    "/dev/kmem"
  1787. X#define MEM    "/dev/mem"
  1788. END_OF_top.local.h
  1789. if test 1208 -ne `wc -c <top.local.h`; then
  1790.     echo shar: \"top.local.h\" unpacked with wrong size!
  1791. fi
  1792. # end of overwriting check
  1793. fi
  1794. if test -f top.man -a "${1}" != "-c" ; then 
  1795.   echo shar: Will not over-write existing file \"top.man\"
  1796. else
  1797. echo shar: Extracting \"top.man\" \(7861 characters\)
  1798. sed "s/^X//" >top.man <<'END_OF_top.man'
  1799. X.\" NOTE:  changes to the manual page for "top" should be made in the
  1800. X.\"        file "top.man" and NOT in the file "top.1".
  1801. X.TH TOP 1 Local
  1802. X.UC 4
  1803. X.SH NAME
  1804. Xtop \- display and update information about the top cpu processes
  1805. X.SH SYNOPSIS
  1806. X.B top
  1807. X[
  1808. X.B \-Sbinu
  1809. X] [
  1810. X.BI \-d count
  1811. X] [
  1812. X.BI \-s time
  1813. X] [
  1814. X.I number
  1815. X]
  1816. X.SH DESCRIPTION
  1817. X.\" This defines appropriate quote strings for nroff and troff
  1818. X.ds lq \&"
  1819. X.ds rq \&"
  1820. X.if t .ds lq ``
  1821. X.if t .ds rq ''
  1822. X.\" Just in case these number registers aren't set yet...
  1823. X.if \nN==0 .nr N 10
  1824. X.if \nD==0 .nr D 5
  1825. X.I Top
  1826. Xdisplays the top
  1827. X.if !\nN==-1 \nN
  1828. Xprocesses on the system and periodically updates this information.
  1829. X.if \nN==-1 \
  1830. X\{\
  1831. XIf standard output is an intelligent terminal (see below) then
  1832. Xas many processes as will fit on the terminal screen are displayed
  1833. Xby default.  Otherwise, a good number of them are shown (around 20).
  1834. X.\}
  1835. XRaw cpu percentage is used to rank the processes.  If
  1836. X.I number
  1837. Xis given, then the top
  1838. X.I number
  1839. Xprocesses will be displayed instead of the default.
  1840. X.PP
  1841. X.I Top
  1842. Xmakes a distinction between terminals that support advanced capabilities
  1843. Xand those that do not.  This
  1844. Xdistinction affects the choice of defaults for certain options.  In the
  1845. Xremainder of this document, an \*(lqintelligent\*(rq terminal is one that
  1846. Xsupports cursor addressing, clear screen, and clear to end of line.
  1847. XConversely, a \*(lqdumb\*(rq terminal is one that does not support such
  1848. Xfeatures.  If the output of
  1849. X.I top
  1850. Xis redirected to a file, it acts as if it were being run on a dumb
  1851. Xterminal.
  1852. X.SH OPTIONS
  1853. X.TP
  1854. X.B \-S
  1855. XShow system processes in the display.  Normally, system processes such as
  1856. Xthe pager and the swapper are not shown.  This option makes them visible.
  1857. X.TP
  1858. X.B \-b
  1859. XUse \*(lqbatch\*(rq mode.  In this mode, all input from the terminal is
  1860. Xignored.  Interrupt characters (such as ^C and ^\e) still have an effect.
  1861. XThis is the default on a dumb terminal, or when the output is not a terminal.
  1862. X.TP
  1863. X.B \-i
  1864. XUse \*(lqinteractive\*(rq mode.  In this mode, any input is immediately
  1865. Xread for processing.  See the section on \*(lqInteractive Mode\*(rq
  1866. Xfor an explanation of
  1867. Xwhich keys perform what functions.  After the command is processed, the
  1868. Xscreen will immediately be updated, even if the command was not
  1869. Xunderstood.  This mode is the default when standard output is an
  1870. Xintelligent terminal.
  1871. X.TP
  1872. X.B \-n
  1873. XUse \*(lqnon-interactive\*(rq mode.  This is indentical to \*(lqbatch\*(rq
  1874. Xmode.
  1875. X.TP
  1876. X.B \-u
  1877. XDo not take the time to map uid numbers to usernames.  Normally,
  1878. X.I top
  1879. Xwill read as much of the file \*(lq/etc/passwd\*(rq as is necessary to map
  1880. Xall the user id numbers it encounters into login names.  This option
  1881. Xdisables all that, while possibly decreasing execution time.  The uid
  1882. Xnumbers are displayed instead of the names.
  1883. X.TP
  1884. X.BI \-d count
  1885. XShow only
  1886. X.I count
  1887. Xdisplays, then exit.  A display is considered to be one update of the
  1888. Xscreen.  This option allows the user to select the number of displays he
  1889. Xwants to see before
  1890. X.I top
  1891. Xautomatically exits.  For intelligent terminals, no upper limit
  1892. Xis set.  The default is 1 for dumb terminals.
  1893. X.TP
  1894. X.BI \-s time
  1895. XSet the delay between screen updates to
  1896. X.I time
  1897. Xseconds.  The default delay between updates is \nD seconds.
  1898. X.PP
  1899. XBoth
  1900. X.I count
  1901. Xand
  1902. X.I number
  1903. Xfields can be specified as \*(lqinfinite\*(rq, indicating that they can
  1904. Xstretch as far as possible.  This is accomplished by using any proper
  1905. Xprefix of the keywords
  1906. X\*(lqinfinity\*(rq,
  1907. X\*(lqmaximum\*(rq,
  1908. Xor
  1909. X\*(lqall\*(rq.
  1910. XThe default for
  1911. X.I count
  1912. Xon an intelligent terminal is, in fact,
  1913. X.BI infinity .
  1914. X.SH "INTERACTIVE MODE"
  1915. XWhen
  1916. X.I top
  1917. Xis running in \*(lqinteractive mode\*(rq, it reads commands from the
  1918. Xterminal and acts upon them accordingly.  In this mode, the terminal is
  1919. Xput in \*(lqCBREAK\*(rq, so that a character will be
  1920. Xprocessed as soon as it is typed.  Almost always, a key will be
  1921. Xpressed when
  1922. X.I top
  1923. Xis between displays; that is, while it is waiting for
  1924. X.I time
  1925. Xseconds to elapse.  If this is the case, the command will be
  1926. Xprocessed and the display will be updated immediately thereafter
  1927. X(reflecting any changes that the command may have specified).  This
  1928. Xhappens even if the command was incorrect.  If a key is pressed while 
  1929. X.I top
  1930. Xis in the middle of updating the display, it will finish the update and
  1931. Xthen process the command.  Some commands require additional information,
  1932. Xand the user will be prompted accordingly.  While typing this information
  1933. Xin, the user's erase and kill keys (as set up by the command
  1934. X.IR stty )
  1935. Xare recognized, and a newline terminates the input.
  1936. X.PP
  1937. XThese commands are currently recognized (^L refers to control-L):
  1938. X.TP
  1939. X.B ^L
  1940. XRedraw the screen.
  1941. X.IP "\fBh\fP\ or\ \fB?\fP"
  1942. XDisplay a summary of the commands (help screen).
  1943. X.TP
  1944. X.B q
  1945. XQuit
  1946. X.IR top.
  1947. X.TP
  1948. X.B d
  1949. XChange the number of displays to show (prompt for new number).
  1950. XRemember that the next display counts as one, so typing
  1951. X.B d1
  1952. Xwill make
  1953. X.I top
  1954. Xshow one final display and then immediately exit.
  1955. X.TP
  1956. X.B n or #
  1957. XChange the number of processes to display (prompt for new number).
  1958. X.TP
  1959. X.B s
  1960. XChange the number of seconds to delay between displays
  1961. X(prompt for new number).
  1962. X.TP
  1963. X.B k
  1964. XSend a signal (\*(lqkill\*(rq by default) to a list of processes.  This
  1965. Xacts similarly to the command
  1966. X.IR kill (1)).
  1967. X.TP
  1968. X.B r
  1969. XChange the priority (the \*(lqnice\*(rq) of a list of processes.
  1970. XThis acts similarly to the command
  1971. X.IR renice (8)).
  1972. X.TP
  1973. X.B e
  1974. XDisplay a list of system errors (if any) generated by the last
  1975. X.BR k ill
  1976. Xor
  1977. X.BR r enice
  1978. Xcommand.
  1979. X.SH "THE DISPLAY"
  1980. XThe top few lines of the display show general information
  1981. Xabout the state of the system, including
  1982. Xthe last process id assigned to a process,
  1983. Xthe three load averages,
  1984. Xthe current time,
  1985. Xthe number of existing processes,
  1986. Xthe number of processes in each state
  1987. X(sleeping, ABANDONED, running, starting, zombies, and stopped),
  1988. Xand a percentage of time spent in each of the processor states
  1989. X(user, nice, system, and idle).
  1990. XIt also includes the amount of virtual and real memory in use
  1991. X(with the amount of memory considered \*(lqactive\*(rq in parentheses) and
  1992. Xthe amount of free memory.
  1993. X.PP
  1994. XThe remainder of the screen displays information about individual
  1995. Xprocesses.  This display is similar in spirit to
  1996. X.IR ps (1)
  1997. Xbut it is not exactly the same.  PID is the process id, USERNAME is the name
  1998. Xof the process's owner (if
  1999. X.B \-u
  2000. Xis specified, a UID column will be substituted for USERNAME),
  2001. XPRI is the current priority of the process,
  2002. XNICE is the nice amount (in the range \-20 to 20),
  2003. XSIZE is the total size of the process (text, data, and stack),
  2004. XRES is the current amount of resident memory (both SIZE and RES are
  2005. Xgiven in kilobytes),
  2006. XSTATE is the current state (one of \*(lqsleep\*(rq, \*(lqWAIT\*(rq,
  2007. X\*(lqrun\*(rq, \*(lqidl\*(rq, \*(lqzomb\*(rq, or \*(lqstop\*(rq),
  2008. XTIME is the number of system and user cpu seconds that the process has used,
  2009. XWCPU is the weighted cpu percentage (this is the same value that
  2010. X.IR ps (1)
  2011. Xdisplays as CPU),
  2012. XCPU is the raw percentage and is the field that is sorted to determine
  2013. Xthe order of the processes, and
  2014. XCOMMAND is the name of the command that the process is currently running
  2015. X(if the process is swapped out, this column is marked \*(lq<swapped>\*(rq).
  2016. X.SH NOTES
  2017. XThe \*(lqABANDONED\*(rq state (known in the kernel as \*(lqSWAIT\*(rq) was
  2018. Xabandoned, thus the name.  A process should never end up in this state.
  2019. X.SH AUTHOR
  2020. XWilliam LeFebvre, Rice University graduate student
  2021. X.SH FILES
  2022. X.DT
  2023. X/dev/kmem        kernel memory
  2024. X.br
  2025. X/dev/mem        physical memory
  2026. X.br
  2027. X/etc/passwd        used to map uid numbers to user names
  2028. X.br
  2029. X/vmunix        system image
  2030. X.SH BUGS
  2031. XThe command name for swapped processes should be tracked down, but this
  2032. Xwould make the program run slower.
  2033. X.PP
  2034. XAs with
  2035. X.IR ps (1),
  2036. Xthings can change while
  2037. X.I top
  2038. Xis collecting information for an update.  The picture it gives is only a
  2039. Xclose approximation to reality.
  2040. X.SH "SEE ALSO"
  2041. Xkill(1),
  2042. Xps(1),
  2043. Xstty(1),
  2044. Xmem(4),
  2045. Xrenice(8)
  2046. END_OF_top.man
  2047. if test 7861 -ne `wc -c <top.man`; then
  2048.     echo shar: \"top.man\" unpacked with wrong size!
  2049. fi
  2050. # end of overwriting check
  2051. fi
  2052. echo shar: End of archive 1 \(of 2\).
  2053. cp /dev/null ark1isdone
  2054. MISSING=""
  2055. for I in 1 2 ; do
  2056.     if test ! -f ark${I}isdone ; then
  2057.     MISSING="${MISSING} ${I}"
  2058.     fi
  2059. done
  2060. if test "${MISSING}" = "" ; then
  2061.     echo You have unpacked both archives.
  2062.     rm -f ark[1-9]isdone
  2063. else
  2064.     echo You still need to unpack the following archives:
  2065.     echo "        " ${MISSING}
  2066. fi
  2067. ##  End of shell archive.
  2068. exit 0
  2069.  
  2070.  
  2071. -- 
  2072.  
  2073. Rich $alz            "Anger is an energy"
  2074. Cronus Project, BBN Labs    rsalz@bbn.com
  2075. Moderator, comp.sources.unix    sources@uunet.uu.net
  2076.