Major upgrade from Lars. The geometry bug has been fixed, and the

swap display improved.

Submitted by:	Lars Köller (Lars_Koeller@odie.physik2.uni-rostock.de)

1 files changed, 554 insertions, 432 deletions

diff --git a/sysutils/xperfmon/files/patch-aa b/sysutils/xperfmon/files/patch-aa
index c73a0099d29f..2faa52e05fe2 100644
--- a/sysutils/xperfmon/files/patch-aa
+++ b/sysutils/xperfmon/files/patch-aa
@@ -1,432 +1,554 @@
-diff -u ../xperfmon++.orig/Imakefile ./Imakefile
---- ../xperfmon++.orig/Imakefile	Wed Jul 27 22:29:29 1994
-+++ ./Imakefile	Sun Nov 12 00:07:24 1995
-@@ -17,15 +17,21 @@
- SYS_MODULE=	sgi_system
- #endif
- 
--EXTRA_LIBRARIES =     $(SUNFLAGS) $(MIPSFLAGS) $(SGIFLAGS)
-+#if defined (i386BsdArchitecture)
-+BSDFLAGS=	-lkvm
-+SYS_MODULE=     bsd_system
-+CC=		gcc
-+#endif
-+
-+EXTRA_LIBRARIES =     $(SUNFLAGS) $(MIPSFLAGS) $(SGIFLAGS) $(BSDFLAGS)
- 
-    INSTPGMFLAGS =  $(INSTKMEMFLAGS)
- LOCAL_LIBRARIES = $(XAWLIB) $(XTOOLLIB) $(XMULIB) $(XLIB)
-        INCLUDES = -I. -I$(TOOLKITSRC) -I$(TOP) -I$(TOP)/X11
--#       INCLUDES = -I. -I$(TOOLKITSRC) -I$(TOP) -I$(TOP)/X11 -I/usr/include/bsd
--     CDEBUGFLAGS = -O
--           SRCS = TimeChart.c StripChart.c misc.c $(SYS_MODULE).c xperfmon.c nfs.c
--           OBJS = TimeChart.o StripChart.o misc.o $(SYS_MODULE).o xperfmon.o nfs.o
-+#      SRCS = TimeChart.c StripChart.c misc.c $(SYS_MODULE).c xperfmon.c nfs.c
-+#      OBJS = TimeChart.o StripChart.o misc.o $(SYS_MODULE).o xperfmon.o nfs.o
-+       SRCS = TimeChart.c StripChart.c misc.c $(SYS_MODULE).c xperfmon.c
-+       OBJS = TimeChart.o StripChart.o misc.o $(SYS_MODULE).o xperfmon.o
- 
- ComplexProgramTarget(xperfmon++)
- 
-diff -u ../xperfmon++.orig/README ./README
---- ../xperfmon++.orig/README	Wed Jul 27 22:29:30 1994
-+++ ./README	Sun Nov 12 00:07:24 1995
-@@ -18,3 +18,20 @@
- 		Research Center, rsmith@proteus.arc.nasa.gov. Imake will build for correct
- 		O/S if x11r5 is fully installed in all the right places.
- 
-+
-+3-15-95		Completely new port of systemdependent file (bsd_system.c) for FreeBSD-2.X
-+		by Lars Köller @University of Rostock, Germany.
-+		E-Mail: <lars.koeller@odie.physik2.uni-rostock.de>
-+
-+8-16-95		Quick and dirty workaround of -geometry option bug.
-+		But there are still some side effects when changing the geometry. 
-+		Fix memory leak in bsd_system.c
-+		by Lars Köller @University of Rostock, Germany.
-+		E-Mail: <lars.koeller@odie.physik2.uni-rostock.de>
-+
-+30-10-95	Change 'Free Mem' graph to 'Free Swap' cause the FreeBSD memory system
-+		tries to minimize the free unused amount of memory.
-+		Include basic support for FreeBSD > 2.1.
-+		Number of interrupts now independent from 
-+		by Lars Köller @University of Rostock, Germany.
-+		E-Mail: <lars.koeller@odie.physik2.uni-rostock.de>
-diff -u ../xperfmon++.orig/TimeChart.h ./TimeChart.h
---- ../xperfmon++.orig/TimeChart.h	Wed Jul 27 22:29:31 1994
-+++ ./TimeChart.h	Sun Nov 12 00:07:24 1995
-@@ -88,12 +88,12 @@
- #define XtCFillRect "FillRect"
- 
- #define XtNgetValue "getValue"
--#define XtNhighlight "highlight"
-+/* #define XtNhighlight "highlight" */
- #define XtNjumpScroll "jumpScroll"
- #define XtNminScale "minScale"
- #define XtNscale "scale"
- #define XtNfillRect "fillRect"
--#define XtNupdate "update"
-+/* #define XtNupdate "update" */
- #define XtNvmunix "vmunix"
-  
- typedef struct _TimeChartRec *TimeChartWidget;
-diff -u ../xperfmon++.orig/XPerfmon++.ad ./XPerfmon++.ad
---- ../xperfmon++.orig/XPerfmon++.ad	Wed Jul 27 22:29:32 1994
-+++ ./XPerfmon++.ad	Sun Nov 12 00:07:23 1995
-@@ -4,24 +4,37 @@
- ! commented out, the "NFS Server" graph background will be the application
- ! default color, unless some other resource file has specified it.
- ! *PerfChart.highAlarm:		99998
-+*perfChartUser.highAlarm:	95
-+*perfChartUser.highWarn:	75
-+
-+*perfChartSystem.highAlarm:	40
-+*perfChartSystem.highWarn:	25
-+
- *perfChartIdle.lowWarn:		10
- *perfChartIdle.lowAlarm:	5
--*perfChartUser.highAlarm:	90
--*perfChartUser.highWarn:	75
--*perfChartSystem.highAlarm:	90
--*perfChartSystem.highWarn:	75
--*perfChartFree.lowWarn:		2000
--*perfChartFree.lowAlarm:	1000
--*perfChartDisk.highWarn:	25
--*perfChartDisk.highAlarm:	50
--*perfChartIntrpts.highWarn:	500
--*perfChartIntrpts.highAlarm:	750
--*perfChartInput.highWarn:	300
--*perfChartInput.highAlarm:	500
--*perfChartOutput.highWarn:	300
--*perfChartOutput.highAlarm:	500
-+
-+*perfChartSwap.highWarn:	50
-+*perfChartSwap.highAlarm:	100
-+
-+*perfChartDisk.highWarn:	50
-+*perfChartDisk.highAlarm:	100
-+
-+*perfChartIntrpts.highWarn:	400
-+*perfChartIntrpts.highAlarm:	600
-+
-+*perfChartInput.highWarn:	500
-+*perfChartInput.highAlarm:	1000
-+
-+*perfChartOutput.highWarn:	500
-+*perfChartOutput.highAlarm:	1000
-+
- *perfChartCollision.highWarn:	20
- *perfChartCollision.highAlarm:	50
--*perfChartNFSClient.highWarn:	200
--*perfChartNFSClient.highAlarm:	400
-+
-+*perfChartNFSClient.highWarn:	100
-+*perfChartNFSClient.highAlarm:	200
-+
-+*perfChartNFSServer.highWarn:	100
-+*perfChartNFSServer.highAlarm:	200
- *font:				6x13
-+
-Only in .: bsd_system.c
-diff -u ../xperfmon++.orig/misc.c ./misc.c
---- ../xperfmon++.orig/misc.c	Wed Jul 27 22:29:33 1994
-+++ ./misc.c	Sun Nov 12 00:07:24 1995
-@@ -58,7 +58,7 @@
-     int i, keycode, length = 0;
- /*    PerfmonWidget pw = (PerfmonWidget) w;*/
- 
--    length = XLookupString(event, strbuf, STRBUFSIZE, &keycode, NULL);
-+    length = XLookupString((XKeyEvent *)event, strbuf, STRBUFSIZE, (KeySym *)&keycode, NULL);
-     switch (keycode) {
-     case 'Q':
-     case 'q':
-diff -u ../xperfmon++.orig/system.h ./system.h
---- ../xperfmon++.orig/system.h	Wed Jul 27 22:29:34 1994
-+++ ./system.h	Sun Nov 12 00:07:24 1995
-@@ -149,7 +149,11 @@
-     "User",
-     "System",
-     "Idle",
-+#ifdef __FreeBSD__
-+    "Swap",
-+#else
-     "Free",
-+#endif
-     "Disk",
-     "Interrupts",
-     "Input",
-@@ -162,7 +166,11 @@
-     "User",
-     "System",
-     "Idle",
-+#ifdef __FreeBSD__
-+    "Swap",
-+#else
-     "Free",
-+#endif
-     "Disk",
-     "Intrpts",
-     "Input",
-@@ -175,7 +183,11 @@
-     "CPU",
-     "CPU",
-     "CPU",
-+#ifdef __FreeBSD__
-+    "Usage (MB)",
-+#else
-     "Memory",
-+#endif
-     "Transfers",
-     "",
-     "Packets",
-diff -u ../xperfmon++.orig/xperfmon++.man ./xperfmon++.man
---- ../xperfmon++.orig/xperfmon++.man	Wed Jul 27 22:29:39 1994
-+++ ./xperfmon++.man	Sun Nov 12 00:14:56 1995
-@@ -94,8 +94,8 @@
- .B \-idlecpu | \+idlecpu
- Graph \fIIdle\fP CPU Percentage.
- .TP 26
--.B \-freemem | \+freemem
--Graph \fIFree Memory\fP.
-+.B \-{freemem/usedswap} | \+{freemem/usedswap}
-+Graph \fIFree Memory/Used Swap (Operating system dependent, swap only for FreeBSD)\fP.
- .TP 26
- .B \-diskxfr | \+diskxfr
- Graph \fIDisk Transfers\fP per interval period.
-@@ -176,8 +176,8 @@
- .B idle
- Set \fIlimit\fP value for Idle CPU Percentage.
- .TP 12
--.B mem
--Set \fIlimit\fP value for Free Memory.
-+.B mem/swap
-+Set \fIlimit\fP value for Free Memory/Used Swap (OS dependent, swap only for FreeBSD).
- .TP 12
- .B disk
- Set \fIlimit\fP value for Disk Transfers.
-@@ -314,7 +314,7 @@
- Set System CPU Percentage resource.
- .TP 16
- .B Free
--Set Free Memory resource.
-+Set Free Memory/Swap resource.
- .TP 16
- .B Disk
- Set Disk Transfer count resource.
-diff -u ../xperfmon++.orig/xperfmon.c ./xperfmon.c
---- ../xperfmon++.orig/xperfmon.c	Wed Jul 27 22:29:39 1994
-+++ ./xperfmon.c	Sun Nov 12 00:13:55 1995
-@@ -58,6 +58,10 @@
-  *
-  */
- 
-+#ifdef __FreeBSD__
-+#include <osreldate.h>
-+#endif
-+
- #include <stdio.h>
- #include <X11/IntrinsicP.h>
- #include <X11/StringDefs.h>
-@@ -94,6 +98,11 @@
-      { NULL,           NULL      },
- };
- 
-+/* LK!!! */
-+#define MIN_WIDTH 240
-+#define MIN_HEIGHT 430
-+
-+
- #define XtNinterval "interval"
- #define XtNcount "count"
- #define XtCCount "Count"
-@@ -171,11 +180,17 @@
- static XrmOptionDescRec optionDescList[] = {
-     { "-interval",  ".interval",    XrmoptionSepArg,    (caddr_t) NULL},
-     { "-immediate", "*PerfChart.immediate", XrmoptionNoArg, "True" },
--
-+#if __FreeBSD_version >= 199504
-+    { "-lowswapAlarm", "*perfChartFree.lowAlarm", XrmoptionSepArg, NULL },
-+    { "-lowswapWarn", "*perfChartFree.lowWarn", XrmoptionSepArg, NULL },
-+    { "-highswapAlarm", "*perfChartFree.highAlarm", XrmoptionSepArg, NULL },
-+    { "-highswapWarn", "*perfChartFree.highWarn", XrmoptionSepArg, NULL },
-+#else
-     { "-lowmemAlarm", "*perfChartFree.lowAlarm", XrmoptionSepArg, NULL },
-     { "-lowmemWarn", "*perfChartFree.lowWarn", XrmoptionSepArg, NULL },
-     { "-highmemAlarm", "*perfChartFree.highAlarm", XrmoptionSepArg, NULL },
-     { "-highmemWarn", "*perfChartFree.highWarn", XrmoptionSepArg, NULL },
-+#endif
- 
-     { "-lowuserAlarm", "*perfChartUser.lowAlarm", XrmoptionSepArg, NULL },
-     { "-lowuserWarn", "*perfChartUser.lowWarn", XrmoptionSepArg, NULL },
-@@ -237,8 +252,13 @@
-     { "+systemcpu", XtNsystemcpuAdd,     XrmoptionNoArg,     "TRUE" },
-     { "-idlecpu",   XtNidlecpuSub,     XrmoptionNoArg,     "True" },
-     { "+idlecpu",   XtNidlecpuAdd,     XrmoptionNoArg,     "TRUE" },
-+#if __FreeBSD_version >= 199504
-+    { "-usedswap",  XtNfreememSub,     XrmoptionNoArg,     "True" },
-+    { "+usedswap",  XtNfreememAdd,     XrmoptionNoArg,     "TRUE" },
-+#else
-     { "-freemem",   XtNfreememSub,     XrmoptionNoArg,     "True" },
-     { "+freemem",   XtNfreememAdd,     XrmoptionNoArg,     "TRUE" },
-+#endif
-     { "-diskxfr",   XtNdiskxfrSub,     XrmoptionNoArg,     "True" },
-     { "+diskxfr",   XtNdiskxfrAdd,     XrmoptionNoArg,     "TRUE" },
-     { "-interrupts",  XtNinterruptsSub ,     XrmoptionNoArg,     "True" },
-@@ -344,7 +364,11 @@
-     fprintf(stderr, "    [{-+}usercpu]          ({remove|add} usercpu to list of graphs\n");
-     fprintf(stderr, "    [{-+}systemcpu]        ({remove|add} systemcpu to list of graphs\n");
-     fprintf(stderr, "    [{-+}idlecpu]          ({remove|add} idlecpu to list of graphs\n");
-+#if __FreeBSD_version >= 199504
-+    fprintf(stderr, "    [{-+}usedswap]         ({remove|add} usedswap to list of graphs\n");
-+#else
-     fprintf(stderr, "    [{-+}freemem]          ({remove|add} freemem to list of graphs\n");
-+#endif
-     fprintf(stderr, "    [{-+}diskxfr]          ({remove|add} disk transfers to list of graphs\n");
-     fprintf(stderr, "    [{-+}interrupts]       ({remove|add} interrupts to list of graphs\n");
-     fprintf(stderr, "    [{-+}inputpkts]        ({remove|add} input packets to list of graphs\n");
-@@ -361,10 +385,18 @@
-     fprintf(stderr, "    [-high*Alarm {value}]     ( Set High Alarm value for *)\n");
-     fprintf(stderr, "    [-high*Warn {value}]      ( Set High Warning value for *)\n");
-     fprintf(stderr, "  Where \"*\" is one of the following:\n");
-+#if __FreeBSD_version >= 199504
-+    fprintf(stderr, "    [swap | user | sys | idle | disk | intrpts |\n");
-+#else
-     fprintf(stderr, "    [mem | user | sys | idle | disk | intrpts |\n");
-+#endif
-     fprintf(stderr, "     input | output | collision | nfsclient | nfsserver]\n");
-     fprintf(stderr, "  For Example:\n");
-+#if __FreeBSD_version >= 199504
-+    fprintf(stderr, "    [-lowswapAlarm {value}]   ( Set low Free Swap Alarm Value)\n");
-+#else
-     fprintf(stderr, "    [-lowmemAlarm {value}]    ( Set low Free Memory Alarm Value)\n");
-+#endif
-     fprintf(stderr, "WARNING: It is an error condition to set both a high, and a low, limit warning or alarm.\n");
-     exit(1);
- }
-@@ -386,6 +418,7 @@
-     time(&timeStamp);
-     return;
- }
-+
- /*ARGSUSED*/
- void handleResize( w, unused, event, contin2disp )
- Widget w;
-@@ -419,9 +452,15 @@
- 	break;
- 
-     }
--    if ( neww < 250 + 10 ) {
--	neww = 250 + 10;
--	w->core.width = 250 + 10;
-+    if ( neww < MIN_WIDTH + 10 ) {
-+	neww = MIN_WIDTH + 10;
-+	w->core.width = MIN_WIDTH + 10;
-+	XtResizeWindow(w);
-+    }
-+/* LK!!! */
-+    if ( newh < MIN_HEIGHT + 10 ) {
-+	newh = MIN_HEIGHT + 10;
-+	w->core.height = MIN_HEIGHT + 10;
- 	XtResizeWindow(w);
-     }
-     if ( appData.debug )
-@@ -436,6 +475,7 @@
- 	Dimension boxH = labelBox->core.height;
- 	Dimension timeH = timechart->core.height;
- 	Dimension newWidgetH = (newh - (boxH+8) - (timeH+10) - hOverHead) / appData.numGraphsOn;
-+
- 	if ( oldWidth == neww && oldHeight == newh ) return;
- 
- 	if ( appData.debug )
-@@ -464,6 +504,9 @@
-     int argc;
-     char **argv;
- {
-+/* LK!!! */
-+    Dimension neww, newh, timeH, newWidgetH, hOverHead, boxH;
-+
-     Arg arg;
-     Pixmap icon_pixmap = None;
-     Widget  loadParent, pappaBox;
-@@ -540,7 +583,6 @@
- 		xperfmon_width, xperfmon_height));
- 	XtSetValues(appData.toplevel, &arg, 1);
-     }
--
- /* create windows */
- 
-     pappaBox = XtVaCreateManagedWidget("PappaBox", boxWidgetClass, appData.toplevel, 
-@@ -553,8 +595,24 @@
-     c = (char *) ((long) &hostname[0] + (int) strlen(hostname));
-     sprintf(c, "\nUpdate Interval = %5.1f secs", (float)(appData.interval*appData.ms_per_sec)/1000.0);
- 
-+/* LK!!! quick and dirty hack */
-+    XtRealizeWidget(appData.toplevel);
-+
-+    neww = appData.toplevel->core.width;
-+    newh = appData.toplevel->core.height;
-+    if ( neww < MIN_WIDTH + 10) {
-+	neww = MIN_WIDTH + 10;
-+	appData.toplevel->core.width = MIN_WIDTH + 10;
-+	XtResizeWindow(appData.toplevel);
-+    }
-+    if ( newh < MIN_HEIGHT + 10) {
-+	newh = MIN_HEIGHT + 10;
-+	appData.toplevel->core.height = MIN_HEIGHT + 10;
-+	XtResizeWindow(appData.toplevel);
-+    }
-+    neww -= 10;
-     labelBox = XtVaCreateManagedWidget("LabelBox", labelWidgetClass, pappaBox,
--					 XtNwidth, 250,
-+					 XtNwidth, neww,
- /*					 XtNheight, 16,*/
- 				         XtNjustify, XtJustifyLeft,
- 				         XtNinternalHeight, 0,
-@@ -562,6 +620,13 @@
- 				         XtNlabel, hostname,
- 				         XtNborderWidth, 0,
- 					 NULL);
-+
-+/* same as in handleResize */
-+    hOverHead = 5 * appData.numGraphsOn;
-+    boxH = labelBox->core.height;
-+    timeH = 18;
-+    newWidgetH = (newh - (boxH+8) - (timeH+10) - hOverHead) / appData.numGraphsOn;
-+
- /* build the graph widgets */
- 
-     for ( i=0; i<NUM_GRAPHS; i++ ) {
-@@ -570,8 +635,8 @@
- 	    perfmon[i] = XtVaCreateManagedWidget(hostname, perfChartWidgetClass, pappaBox, 
- 						 XtNtopLabel, topNames[i],
- 						 XtNbotLabel, botNames[i],
--						 XtNwidth, 250,
--						 XtNheight, 36,
-+						 XtNwidth, neww,
-+						 XtNheight,  newWidgetH,
- 						 XtNupdate, appData.interval*appData.ms_per_sec,
- 						 XtNfillRect, (int)appData.fill,
- 						 XtNjumpScroll, 1,
-@@ -580,7 +645,7 @@
-     }
-     timechart = XtVaCreateManagedWidget("timeChart", timeChartWidgetClass, pappaBox, 
- 					 XtNfromVert, perfmon[1], 
--					 XtNwidth, 250,
-+					 XtNwidth, neww,
- 					 XtNheight, 18,
- 					 XtNupdate, appData.interval*appData.ms_per_sec,
- 					 XtNjumpScroll, 1,
-@@ -590,7 +655,7 @@
- 
-     for ( i=0; i<NUM_GRAPHS; i++ ) 
- 	if ( appData.graphOn[i] ) 
--	    XtAddCallback(perfmon[i], XtNgetValue, update_stat, i);
-+	    XtAddCallback(perfmon[i], XtNgetValue, update_stat, (XtPointer)i);
- 
-     appData.interval_id = XtAppAddTimeOut(appData.app_context,
- 		    appData.interval*appData.ms_per_sec, start_graphs, (caddr_t) appData.toplevel);
-@@ -598,3 +663,4 @@
-     XtRealizeWidget(appData.toplevel);
-     XtAppMainLoop(appData.app_context);
- }
-+
+diff -c -N ../xperfmon++/bsd_system.c ./bsd_system.c
+*** ../xperfmon++/bsd_system.c	Thu Jan  1 01:00:00 1970
+--- ./bsd_system.c	Fri Dec 15 11:00:03 1995
+***************
+*** 0 ****
+--- 1,548 ----
++ /*
++  * Perfmon Performance Monitor
++  *
++  * Copyright 1985, Massachusetts Institute of Technology
++  * Copyright 1989, PCS Computer Systeme GmbH, West Germany
++  * Copyright 1994, Sterling Software @ NASA-Ames Research Center
++  * Copyright 1995, Regents of the University of California,
++  *                 Lars Köller <Lars_Koeller@odie.physik2.uni-rostock.de
++  *
++  * Permission to use, copy, modify, distribute, and sell this software and its
++  * documentation for any purpose is hereby granted without fee, provided that
++  * the above copyright notice appear in all copies and that both that
++  * copyright notice and this permission notice appear in supporting
++  * documentation, and that the name of PCS and Sterling Software not be used in advertising or
++  * publicity pertaining to distribution of the software without specific,
++  * written prior permission.  PCS and Sterling Software makes no representations about the
++  * suitability of this software for any purpose.  It is provided "as is"
++  * without express or implied warranty.
++  *
++  * PCS & STERLING SOFTWARE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
++  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL PCS & STERLING SOFTWARE
++  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
++  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
++  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
++  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
++  *
++  * Original Author:  Emanuel Jay Berkenbilt, MIT Project Athena
++  * Author:           Thomas A. Baghli, PCS Computer Systeme GmbH, West Germany
++  *                   tom@meepmeep.pcs.com
++  * 1994 Revision
++  * Author:           Roger Smith, Sterling Software @ NASA-Ames Research Center
++  *                   Moffett Field, California, rsmith@proteus.arc.nasa.gov
++  * 1995 FreeBSD 2.x Version
++  * Author:           Lars Koeller, Univerity of Rostock, Germany
++  *                   Lars_Koeller@odie.physik2.uni-rostock.de
++  */
++ 
++ /* This file contains only system functions - that is the functions that
++  * get the information the performance monitor is monitoring.  No calls
++  * to any X routines should be made here.  The reason for doing this is
++  * so that as the X toolkit becomes available and the X window system 
++  * improves no changes will have to be made to this file, and as this
++  * program is made available for a new type of machine, only this file
++  * will need to be changed.
++  */
++ #include <X11/IntrinsicP.h>
++ 
++ #include "system.h"
++ 
++ #include <stdio.h>
++ #include <stdlib.h>
++ #include <strings.h>
++ #include <unistd.h>
++ #include <paths.h>
++ #include <kvm.h>
++ #include <nlist.h>
++ #include <limits.h>
++ #include <errno.h>
++ #include <err.h>
++ 
++ #include <sys/file.h>
++ #include <sys/param.h>
++ #include <sys/socket.h>
++ #include <sys/sysctl.h>
++ #include <sys/dkstat.h>
++ #include <sys/buf.h>
++ #include <sys/vmmeter.h>
++ #include <vm/vm.h>
++ #include <net/if.h>
++ #include <netinet/in.h>
++ #include <sys/stat.h>
++ #include <sys/conf.h>
++ #include <sys/rlist.h>
++ #include <sys/mount.h>
++ #include <nfs/nfsv2.h>
++ #include <nfs/nfs.h>
++ 
++ 
++ #if __FreeBSD__ > 1
++ #include <osreldate.h>
++ /*
++  * XXX temporary hack: FreeBSD-2.2-current has been floating around
++  * with 199508 for some time; FreeBSD-2.1 will be 199511 however (so
++  * 2.2-current has been bumped to 199512 recently).  Recognize the old
++  * 2.2-current as NFSv3 for a grace period.
++  * FreeBSD 2.0.5 was 199504, btw.  Both, 2.0.5 and 2.1 don't have
++  * NFSv3.
++  */
++ #  if __FreeBSD_version > 199511 || __FreeBSD_version == 199508
++ #    define HAS_NFS_V3
++ #  endif /* FreeBSD_version */
++ #endif /* FreeBSD */
++ 
++ #include "is.h"
++ 
++ #ifndef TRUE
++ #define TRUE 1
++ #define FALSE 0
++ #endif
++ 
++ #define WANT_STAT(x) (poss_stats[(x)] != NO_STAT)
++ 
++ /*
++     Function Prototypes
++ */
++ static int get_namelist(const char *kernel_name, const char *memory_name);
++ static void kread(int nlx, void *addr, size_t size);
++ static void collect_stats(void);
++ static int total_disk_transfers(void);
++ static int get_swapspace(void);
++ 
++ /*
++     Variables & Structs
++ */
++ static unsigned long *intrcnt;
++ static int nintr, hz;
++ static kvm_t *kd;
++ static char errbuf[_POSIX2_LINE_MAX];
++ static char dr_name[DK_NDRIVE][DK_NAMELEN];
++ static double etime;
++ 
++ int current_values[NUM_GRAPHS];
++ stat_type stats;
++ 
++ extern Widget perfmon[NUM_GRAPHS];
++ 
++ static struct packet {
++     int input, output, collisions;
++ } packets, old_packets;
++ 
++ static struct nfsstats nfsstats;
++ static struct _nfsStats {
++     int nfsServer, nfsClient;
++ } nfsStats, old_nfsStats;
++ 
++ struct nlist nl[] = {
++ #define X_CPTIME	0
++ 	{ "_cp_time" },
++ #define X_SUM	   	1
++ 	{ "_cnt" },
++ #define X_BOOTTIME      2
++ 	{ "_boottime" },
++ #define X_DKXFER	3
++ 	{ "_dk_xfer" },
++ #define X_HZ	    	4
++ 	{ "_hz" },
++ #define N_IFNET       	5
++ 	{ "_ifnet" },
++ #define X_INTRCNT 	6
++         { "_intrcnt" },
++ #define X_EINTRCNT 	7
++         { "_eintrcnt" },
++ #define VM_NSWAP        8
++         { "_nswap" },   /* size of largest swap device */
++ #define VM_NSWDEV       9
++         { "_nswdev" },  /* number of swap devices */
++ #define VM_DMMAX        10
++         { "_dmmax" },   /* maximum size of a swap block */
++ #define VM_SWAPLIST     11
++         { "_swaplist" },/* list of free swap areas */
++ #define VM_SWDEVT       12
++         { "_swdevt" },  /* list of swap devices and sizes */
++         { "" },
++ };
++ 
++ struct {
++ 	long    time[CPUSTATES];
++ 	long    xfer[DK_NDRIVE];
++ 	struct  vmmeter Sum;
++ 	struct  vmmeter Rate;
++ 	int interrupts;
++ } s, s1;
++ 
++ int off;
++ 
++ #define rate s.Rate
++ #define sum  s.Sum
++ 
++ /*
++     This routine does all necessary setting up of structures
++     that will handle system calls.
++ */
++ void sys_setup()
++ {
++     get_namelist(getbootfile(), _PATH_KMEM);
++     collect_stats();
++     /* hack to enforce a resize of the 'Free Swap' graph
++        without this the left border always displays the first drawn line
++        cause this field isn't resized very often due to slow change of
++        the free swapspace! */
++     off = 100 - get_swapspace();
++     etime = 1.0;
++ }
++ 
++ 
++ /*
++     Update the data structures
++ */
++ void update_stats()
++ {
++     int state;
++     double pct, tot;;
++ 
++     collect_stats();
++ 
++     tot = 0;
++     for (state = 0; state < CPUSTATES; ++state)
++         tot += s.time[state];
++     if (tot)
++         pct = 100 / tot;
++     else
++         pct = 0;
++     current_values[USER_CPU_PERCENTAGE] = (s.time[CP_USER] + s.time[CP_NICE]) * pct;
++     current_values[SYSTEM_CPU_PERCENTAGE] = (s.time[CP_SYS] + s.time[CP_INTR]) * pct;;
++     current_values[IDLE_CPU_PERCENTAGE] = s.time[CP_IDLE] * pct;
++ 
++     if (perfmon[FREE_MEM]) {
++ 	current_values[FREE_MEM] = get_swapspace() + off;
++ 	off = 0;
++       }
++     if (perfmon[DISK_TRANSFERS])
++ 	current_values[DISK_TRANSFERS] = total_disk_transfers();
++     if (perfmon[INTERRUPTS])
++       current_values[INTERRUPTS] = (s.interrupts - s1.interrupts)/etime;
++     if (perfmon[INPUT_PACKETS])
++ 	current_values[INPUT_PACKETS] = (packets.input - old_packets.input)/etime;
++     if (perfmon[OUTPUT_PACKETS])
++ 	current_values[OUTPUT_PACKETS] = (packets.output - old_packets.output)/etime;
++     if (perfmon[COLLISION_PACKETS])
++ 	current_values[COLLISION_PACKETS] = (packets.collisions - old_packets.collisions)/etime;
++     if (perfmon[NFS_CLIENT_CALLS])
++ 	current_values[NFS_CLIENT_CALLS] = (nfsStats.nfsClient - old_nfsStats.nfsClient)/etime;
++     if (perfmon[NFS_SERVER_CALLS])
++ 	current_values[NFS_SERVER_CALLS] = (nfsStats.nfsServer - old_nfsStats.nfsServer)/etime;
++ }
++ 
++ 
++ /*
++     Collect the overall disk transfer rates
++ */
++ int
++ total_disk_transfers()
++ {
++     register int i, total_xfers = 0;
++ 
++     for(i=0; i < DK_NDRIVE; i++)
++ 	total_xfers += s.xfer[i];
++     return(total_xfers/etime);
++ }
++ 
++ 
++ /*
++     Collect all the data
++ */
++ void
++ collect_stats()
++ {
++     off_t ifnetaddr;
++     register int i, tmp;
++     int mib[3], size;
++ 
++     kread(X_CPTIME, s.time, sizeof(s.time));
++     kread(X_DKXFER, s.xfer, sizeof(s.xfer));
++     kread(X_SUM, &sum, sizeof(sum) );
++ 
++     nintr = nl[X_EINTRCNT].n_value - nl[X_INTRCNT].n_value;
++     if ((intrcnt = (unsigned long *) malloc((size_t) nintr)) == NULL)
++       err(1, "xperfmon++ malloc in collect_stats");
++     nintr /= sizeof(long);    
++     kread(X_INTRCNT, intrcnt, (size_t) nintr*sizeof(long));
++     s1.interrupts = s.interrupts;
++     s.interrupts = 0;
++     for (i = 0; i < nintr; i++)
++         s.interrupts += *(intrcnt + i);
++ 
++     free(intrcnt);
++     etime = 0;
++     for (i=0; i < DK_NDRIVE; i++) {
++ 	tmp = s.xfer[i];
++ 	s.xfer[i] -= s1.xfer[i];
++ 	s1.xfer[i] = tmp;
++     }
++     for (i=0; i < CPUSTATES; i++) {
++ 	tmp = s.time[i];
++ 	s.time[i] -= s1.time[i];
++ 	s1.time[i] = tmp;
++ 	etime += s.time[i];
++     }
++     if(etime == 0.)
++ 	etime = 1.;
++     etime /= hz;
++ 
++ /*
++     Collect the Network-Traffic
++ */
++ 
++     if (nl[N_IFNET].n_value != 0) {
++ 	struct ifnet ifnet;
++ 	kread(N_IFNET, &ifnetaddr, sizeof(ifnetaddr));
++ 	old_packets = packets;
++ 	packets.input = packets.output = packets.collisions = 0;
++ 	while (ifnetaddr) {
++ 	    kvm_read(kd, ifnetaddr, &ifnet, sizeof ifnet );
++ 	    packets.input += ifnet.if_ipackets;
++ 	    packets.output += ifnet.if_opackets;
++ 	    packets.collisions += ifnet.if_collisions;
++ 	    ifnetaddr = (u_long) ifnet.if_next;
++ 	}
++     }
++ 
++ /*
++     Collect the NFS and RPC Calls
++ */
++ 
++     size = sizeof(nfsstats);
++     mib[0] = CTL_FS;
++     mib[1] = MOUNT_NFS;
++     mib[2] = NFS_NFSSTATS;
++ 
++     if (sysctl( mib, 3, &nfsstats, &size, NULL, 0) < 0)
++         return;
++     else {
++         old_nfsStats = nfsStats;
++ 
++         nfsStats.nfsClient = nfsstats.rpccnt[NFSPROC_GETATTR] + 
++                              nfsstats.rpccnt[NFSPROC_SETATTR] +
++                              nfsstats.rpccnt[NFSPROC_LOOKUP] +
++                              nfsstats.rpccnt[NFSPROC_READLINK] +
++                              nfsstats.rpccnt[NFSPROC_READ] +
++                              nfsstats.rpccnt[NFSPROC_WRITE] +
++                              nfsstats.rpccnt[NFSPROC_CREATE] +
++                              nfsstats.rpccnt[NFSPROC_REMOVE] +
++                              nfsstats.rpccnt[NFSPROC_RENAME] +
++                              nfsstats.rpccnt[NFSPROC_LINK] +
++                              nfsstats.rpccnt[NFSPROC_SYMLINK] +
++                              nfsstats.rpccnt[NFSPROC_MKDIR] +
++                              nfsstats.rpccnt[NFSPROC_RMDIR] + 
++                              nfsstats.rpccnt[NFSPROC_READDIR] +
++ #ifndef HAS_NFS_V3
++                              nfsstats.rpccnt[NFSPROC_STATFS] +
++                              nfsstats.rpccnt[NQNFSPROC_READDIRLOOK] +
++ #else /* HAS_NFS_V3 */
++                              nfsstats.rpccnt[NFSPROC_READDIRPLUS] +
++                              nfsstats.rpccnt[NFSPROC_FSSTAT] +
++                              nfsstats.rpccnt[NFSPROC_FSINFO] +
++                              nfsstats.rpccnt[NFSPROC_PATHCONF] +
++                              nfsstats.rpccnt[NFSPROC_COMMIT] +
++ #endif /* HAS_NFS_V3 */
++                              nfsstats.rpccnt[NQNFSPROC_GETLEASE] +
++                              nfsstats.rpccnt[NQNFSPROC_VACATED] +
++                              nfsstats.rpccnt[NQNFSPROC_EVICTED];
++ 
++         nfsStats.nfsServer = nfsstats.srvrpccnt[NFSPROC_GETATTR] + 
++                              nfsstats.srvrpccnt[NFSPROC_SETATTR] +
++                              nfsstats.srvrpccnt[NFSPROC_LOOKUP] +
++                              nfsstats.srvrpccnt[NFSPROC_READLINK] +
++                              nfsstats.srvrpccnt[NFSPROC_READ] +
++                              nfsstats.srvrpccnt[NFSPROC_WRITE] +
++                              nfsstats.srvrpccnt[NFSPROC_CREATE] +
++                              nfsstats.srvrpccnt[NFSPROC_REMOVE] +
++                              nfsstats.srvrpccnt[NFSPROC_RENAME] +
++                              nfsstats.srvrpccnt[NFSPROC_LINK] +
++                              nfsstats.srvrpccnt[NFSPROC_SYMLINK] +
++                              nfsstats.srvrpccnt[NFSPROC_MKDIR] +
++                              nfsstats.srvrpccnt[NFSPROC_RMDIR] + 
++                              nfsstats.srvrpccnt[NFSPROC_READDIR] +
++ #ifndef HAS_NFS_V3
++                              nfsstats.srvrpccnt[NFSPROC_STATFS] +
++                              nfsstats.srvrpccnt[NQNFSPROC_READDIRLOOK] +
++ #else /* HAS_NFS_V3 */
++                              nfsstats.srvrpccnt[NFSPROC_READDIRPLUS] +
++                              nfsstats.srvrpccnt[NFSPROC_FSSTAT] +
++                              nfsstats.srvrpccnt[NFSPROC_FSINFO] +
++                              nfsstats.srvrpccnt[NFSPROC_PATHCONF] +
++                              nfsstats.srvrpccnt[NFSPROC_COMMIT] +
++ #endif /* HAS_NFS_V3 */
++                              nfsstats.srvrpccnt[NQNFSPROC_GETLEASE] +
++                              nfsstats.srvrpccnt[NQNFSPROC_VACATED] +
++                              nfsstats.srvrpccnt[NQNFSPROC_EVICTED];
++     }
++ }
++ 
++ 
++ /*
++     Reads the nlist from the kernel
++ */
++ int
++ get_namelist(kernel_name, memory_name)
++     const char *kernel_name, *memory_name;
++ {
++     time_t now;
++     time_t boottime;
++     register int i, c;
++     int nintv;
++ 
++     kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, errbuf);
++     if (kd == 0) {
++         (void)fprintf(stderr, "xperfmon++: kvm_openfiles: %s\n", errbuf);
++         exit(1);
++     }
++ 
++     if ((c = kvm_nlist(kd, nl)) != 0) {
++         if (c > 0) {
++             (void)fprintf(stderr,"xperfmon++: undefined symbols:");
++             for (c = 0; c < sizeof(nl)/sizeof(nl[0]); c++)
++                 if (nl[c].n_type == 0)
++                     fprintf(stderr, " %s", nl[c].n_name);
++             (void)fputc('\n', stderr);
++         } else
++             (void)fprintf(stderr, "xperfmon++: kvm_nlist: %s\n", kvm_geterr(kd));            exit(1);
++     }
++ 
++     kread(X_BOOTTIME, &boottime, sizeof(boottime));
++     kread(X_HZ, &hz, sizeof(hz));
++     for (i = 0; i < DK_NDRIVE; i++) {
++ 	strcpy(dr_name[i], "xx");
++     }
++     time(&now);
++     nintv = now - boottime;
++     if (nintv <= 0 || nintv > 60*60*24*365*10) {
++ 	fprintf(stderr,
++ 	    "Time makes no sense... namelist must be wrong.\n");
++ 	exit(1);
++     }
++     return(nintv);
++ }
++ 
++ 
++ /*
++     Kread reads something from the kernel, given its nlist index.
++ */
++ static void
++ kread(nlx, addr, size)
++         int nlx;
++         void *addr;
++         size_t size;
++ {
++         char *sym;
++         
++         if (nl[nlx].n_type == 0 || nl[nlx].n_value == 0) {
++                 sym = nl[nlx].n_name;
++                 if (*sym == '_')
++                         ++sym;
++                 (void)fprintf(stderr,
++                     "xpermon++: symbol %s not defined\n", sym);
++                 exit(1);
++         }
++         if (kvm_read(kd, nl[nlx].n_value, addr, size) != size) {
++                 sym = nl[nlx].n_name;
++                 if (*sym == '_')
++                        ++sym;
++                 (void)fprintf(stderr, "xperfmon++: %s: %s\n", sym, kvm_geterr(kd));
++                 exit(1);
++         }
++ }
++ 
++ /*
++  * get_swapspace is based on a program called swapinfo written
++  * by Kevin Lahey <kml@rokkaku.atl.ga.us>.
++  */
++ int
++ get_swapspace()
++ {
++ 	char *header;
++ 	int hlen, nswap, nswdev, dmmax;
++ 	int i, div, avail, nfree, npfree, used;
++ 	struct swdevt *sw;
++ 	long blocksize, *perdev;
++ 	struct rlist head;
++ 	struct rlist *swaplist;
++ 	u_long ptr;
++ 	kread(VM_NSWAP, &nswap, sizeof(nswap));
++ 	kread(VM_NSWDEV, &nswdev, sizeof(nswdev));
++ 	kread(VM_DMMAX, &dmmax, sizeof(dmmax));
++ 	kread(VM_SWAPLIST, &swaplist, sizeof(swaplist));
++ 	if ((sw = malloc(nswdev * sizeof(*sw))) == NULL ||
++ 	    (perdev = malloc(nswdev * sizeof(*perdev))) == NULL)
++ 		err(1, "xperfmon++ malloc in get_swapspace");
++ 	kread(VM_SWDEVT, &ptr, sizeof(ptr));
++ 	kvm_read(kd, ptr, sw, nswdev * sizeof(*sw));
++ 	/* Count up swap space. */
++ 	nfree = 0;
++ 	memset(perdev, 0, nswdev * sizeof(*perdev));
++ 	while (swaplist) {
++ 		int	top, bottom, next_block;
++ 		kvm_read(kd, (u_long)swaplist, &head, sizeof(struct rlist));
++ 		top = head.rl_end;
++ 		bottom = head.rl_start;
++ 
++ 		nfree += top - bottom + 1;
++ 
++ 		/*
++ 		 * Swap space is split up among the configured disks.
++ 		 *
++ 		 * For interleaved swap devices, the first dmmax blocks
++ 		 * of swap space some from the first disk, the next dmmax
++ 		 * blocks from the next, and so on up to nswap blocks.
++ 		 *
++ 		 * The list of free space joins adjacent free blocks,
++ 		 * ignoring device boundries.  If we want to keep track
++ 		 * of this information per device, we'll just have to
++ 		 * extract it ourselves.
++ 		 */
++ 		while (top / dmmax != bottom / dmmax) {
++ 			next_block = ((bottom + dmmax) / dmmax);
++ 			perdev[(bottom / dmmax) % nswdev] +=
++ 				next_block * dmmax - bottom;
++ 			bottom = next_block * dmmax;
++ 		}
++ 		perdev[(bottom / dmmax) % nswdev] +=
++ 			top - bottom + 1;
++ 
++ 		swaplist = head.rl_next;
++         }
++ 
++ 	header = getbsize(&hlen, &blocksize);
++ 	div = blocksize / 512;
++ 	avail = npfree = 0;
++ 	for (i = 0; i < nswdev; i++) {
++ 		int xsize, xfree;
++ 
++ 		/*
++ 		 * Don't report statistics for partitions which have not
++ 		 * yet been activated via swapon(8).
++ 		 */
++ 		if (!(sw[i].sw_flags & SW_FREED))
++ 			continue;
++ 
++ 		/* The first dmmax is never allocated to avoid trashing of
++ 		 * disklabels
++ 		 */
++ 		xsize = sw[i].sw_nblks - dmmax;
++ 		xfree = perdev[i];
++ 		used = xsize - xfree;
++ 		npfree++;
++ 		avail += xsize;
++ 	}
++ 
++ 	/*
++ 	 * If only one partition has been set up via swapon(8), we don't
++ 	 * need to bother with totals.
++ 	 */
++ 	used = avail - nfree;
++ 
++ 	free(perdev);
++ 	free(sw);
++ 	return((100*nfree)/avail);   /* return free swap in percent */
++ }