diff options
Diffstat (limited to 'sysutils/xperfmon/files/patch-aa')
| -rw-r--r-- | sysutils/xperfmon/files/patch-aa | 986 |
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 */ ++ } |