projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add spl's around queue manipulation
[unix-history] / usr / src / usr.bin / systat / vmstat.c
#ifndef lint
static char sccsid[] = "@(#)vmstat.c 1.1 (Berkeley) %G%";
#endif
/*
* Cursed vmstat -- from Robert Elz.
*/
#include <curses.h>
#include <signal.h>
#include <nlist.h>
/* this is STUPID!
#include <sys/time.h>
*/
#include <ctype.h>
#include <utmp.h>
#include <sys/param.h>
#include <sys/vm.h>
#include <sys/dk.h>
#include <sys/buf.h>
#include <vaxuba/ubavar.h>
#include <vaxmba/mbavar.h>
#include <sys/stat.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <vax/pte.h>
#include <sys/nami.h>
#if DK_NDRIVE > 6
#undef DK_NDRIVE
#define DK_NDRIVE 6
#endif
char *fread();
long time();
float cputime();
char *asctime();
struct tm *localtime();
void finish();
void docmd();
struct utmp utmp;
struct nlist name[] = {
{ "_cp_time" },
#define X_CPTIME 0
{ "_rate" },
#define X_RATE 1
{ "_total" },
#define X_TOTAL 2
{ "_avenrun" },
#define X_AVENRUN 3
{ "_proc" },
#define X_PROC 4
{ "_nproc" },
#define X_NPROC 5
{ "_bootime" },
#define X_BOOTIME 6
{ "_deficit" },
#define X_DEFICIT 7
{ "_ubdinit" },
#define X_UBDINIT 8
{ "_mbdinit" },
#define X_MBDINIT 9
{ "_sum" },
#define X_SUM 10
{ "_dk_busy" },
#define X_DK_BUSY 11
{ "_dk_time" },
#define X_DK_TIME 12
{ "_dk_xfer" },
#define X_DK_XFER 13
{ "_dk_wds" },
#define X_DK_WDS 14
{ "_tk_nin" },
#define X_TK_NIN 15
{ "_tk_nout" },
#define X_TK_NOUT 16
{ "_dk_seek" },
#define X_DK_SEEK 17
{ "_dk_mspw" },
#define X_DK_MSPW 18
{ "_hz" },
#define X_HZ 19
{ "_phz" },
#define X_PHZ 20
{ "_nchstats" },
#define X_NCHSTATS 21
{ 0 },
};
struct Info {
long time[CPUSTATES];
struct vmmeter Rate;
struct vmtotal Total;
struct vmmeter Sum;
struct forkstat Forkstat;
long dk_time[DK_NDRIVE];
long dk_wds[DK_NDRIVE];
long dk_seek[DK_NDRIVE];
long dk_xfer[DK_NDRIVE];
float dk_mspw[DK_NDRIVE];
int dk_busy;
long tk_nin;
long tk_nout;
struct nchstats nchstats;
long nchcount;
} s, s1, s2, z;
#define total s.Total
#define sum s.Sum
#define sumold s1.Sum
#define rate s.Rate
#define nchtotal s.nchstats
#define oldnchtotal s1.nchstats
#define oldrate s1.Rate
#define X(fld) {t=s.fld[i]; s.fld[i]-=s1.fld[i]; if(state==TIME) s1.fld[i]=t;}
#define Y(fld) {t = s.fld; s.fld -= s1.fld; if(state == TIME) s1.fld = t;}
#define Z(fld) {t = s.nchstats.fld; s.nchstats.fld -= s1.nchstats.fld; \
if(state == TIME) s1.nchstats.fld = t;}
int ut;
int kmem;
int deficit;
double avenrun[3];
long c;
char buf[26];
time_t t;
time_t bootime;
double etime;
int secs;
int delay = 1;
int hz;
int phz;
float hertz;
char dr_name[DK_NDRIVE][10];
enum state { BOOT, TIME, RUN, STOP } state = TIME;
enum { NONE, SOME } dr_state[DK_NDRIVE];
char cpuchar[CPUSTATES] = { '=' , '>', '-', ' ' };
char cpuorder[CPUSTATES] = { CP_SYS, CP_USER, CP_NICE, CP_IDLE };
main(argc,argv)
int argc;
char **argv;
{
time_t now, lastime, starttime;
int i, l, c;
int psiz;
int interv;
int hits;
float f1, f2;
if (argc > 1)
switch (c = argv[1][0] == '-' ? argv[1][1] : argv[1][0]) {
case 't':
state = TIME;
break;
case 'r':
state = RUN;
break;
case 'b':
state = BOOT;
break;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
delay = c - '0';
break;
}
if ((kmem = open("/dev/kmem",0)) < 0) {
fprintf(stderr, "No /dev/kmem \n");
exit(1);
}
if ((ut = open("/etc/utmp", 0)) < 0) {
fprintf(stderr, "No utmp\n");
exit(1);
}
nlist("/vmunix",name);
if (name[0].n_type == 0) {
fprintf(stderr, "No namelist\n");
exit(1);
}
lseek(kmem, (long)name[X_HZ].n_value, 0);
read(kmem, &hz, sizeof hz);
lseek(kmem, (long)name[X_PHZ].n_value, 0);
read(kmem, &phz, sizeof phz);
hertz = phz ? phz : hz;
lseek(kmem, (long)name[X_DK_MSPW].n_value, 0);
read(kmem, s.dk_mspw, sizeof s.dk_mspw);
for (i = 0; i < DK_NDRIVE; i++)
if (s.dk_mspw[i] == 0.0)
dr_state[i] = NONE;
else
dr_state[i] = SOME;
read_names();
initscr();
signal(SIGINT, finish);
noecho();
crmode();
layout();
time(&lastime);
starttime = lastime;
getinfo(&s2, RUN);
if (state == RUN)
s1 = s2;
/* if included, this starts TIME at zeroes, else == boot
else if (state == TIME)
getinfo(&s1, TIME)
*/
lseek(kmem, (long)name[X_BOOTIME].n_value, 0);
read(kmem, &bootime, sizeof bootime);
for (;;) {
while (state == STOP)
waittty(delay*10);
time(&now);
strcpy(buf, ctime(&now));
buf[16] = '\0';
getinfo(&s, state);
for (i = 0; i < DK_NDRIVE; i++) {
X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time);
}
Y(tk_nin); Y(tk_nout);
etime = 0;
for(i=0; i<CPUSTATES; i++) {
X(time);
etime += s.time[i];
}
if (etime < 5.0) /* < 5 ticks - ignore this trash */
continue;
/*
if (etime == 0.0)
etime = 1.0;
*/
etime /= hertz;
Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss);
Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes);
s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits +
nchtotal.ncs_miss + nchtotal.ncs_long;
if (state == TIME)
s1.nchcount = s.nchcount;
psiz = 0;
f2 = 0.0;
for (c=0; c<CPUSTATES; c++) {
i = cpuorder[c];
f1 = cputime(i);
f2 += f1;
l = (int) ((f2 + 1.0) / 2.0) - psiz;
putfloat(f1, 15, 10 + 11*c, 4, 1, 0);
move(17, 5+psiz);
psiz += l;
while (l-- > 0)
addch(cpuchar[c]);
}
putint(ucount(), 1, 1, 3);
putfloat(avenrun[0], 1, 18, 6, 2, 0);
putfloat(avenrun[1], 1, 24, 6, 2, 0);
putfloat(avenrun[2], 1, 30, 6, 2, 0);
mvaddstr(1, 58, buf);
putint(total.t_arm/2, 5, 5, 5);
putint(total.t_armtxt/2, 5, 10, 5);
putint(total.t_avm/2, 5, 15, 5);
putint(total.t_avmtxt/2, 5, 20, 5);
putint(total.t_rm/2, 6, 5, 5);
putint(total.t_rmtxt/2, 6, 10, 5);
putint(total.t_vm/2, 6, 15, 5);
putint(total.t_vmtxt/2, 6, 20, 5);
putint(total.t_free/2, 5, 27, 5);
putint(total.t_rq, 17, 62, 3);
putint(total.t_pw, 17, 65, 3);
putint(total.t_dw, 17, 68, 3);
putint(total.t_sl, 17, 71, 3);
putint(total.t_sw, 17, 74, 3);
putrate(rate.v_swtch, oldrate.v_swtch, 3, 75, 4);
putrate(rate.v_trap, oldrate.v_trap, 4, 75, 4);
putrate(rate.v_syscall, oldrate.v_syscall, 5, 75, 4);
putrate(rate.v_intr, oldrate.v_intr, 6, 75, 4);
putrate(rate.v_pdma, oldrate.v_pdma, 7, 75, 4);
putrate(rate.v_faults, oldrate.v_faults, 8, 75, 4);
putrate(rate.v_scan, oldrate.v_scan, 9, 75, 4);
putrate(rate.v_rev, oldrate.v_rev, 10, 75, 4);
putrate(rate.v_pgin, oldrate.v_pgin, 5, 45, 5);
putrate(rate.v_pgout, oldrate.v_pgout, 5, 50, 5);
putrate(rate.v_swpin, oldrate.v_swpin, 5, 55, 5);
putrate(rate.v_swpout, oldrate.v_swpout, 5, 60, 5);
putrate(rate.v_pgpgin, oldrate.v_pgpgin, 6, 45, 5);
putrate(rate.v_pgpgout, oldrate.v_pgpgout, 6, 50, 5);
putrate(rate.v_pswpin, oldrate.v_pswpin, 6, 55, 5);
putrate(rate.v_pswpout, oldrate.v_pswpout, 6, 60, 5);
putrate(rate.v_pgrec, oldrate.v_pgrec, 9, 40, 3);
putrate(rate.v_intrans, oldrate.v_intrans, 9, 44, 2);
putrate(rate.v_xsfrec, oldrate.v_xsfrec, 9, 47, 3);
putrate(rate.v_xifrec, oldrate.v_xifrec, 9, 51, 3);
putrate(rate.v_pgfrec, oldrate.v_pgfrec, 9, 55, 3);
putrate(rate.v_dfree, oldrate.v_dfree, 9, 59, 3);
putrate(rate.v_seqfree, oldrate.v_seqfree, 9, 63, 3);
putrate(rate.v_zfod, oldrate.v_zfod, 11, 40, 8);
putrate(rate.v_nzfod, oldrate.v_nzfod, 12, 40, 8);
putrate(rate.v_exfod, oldrate.v_exfod, 11, 54, 8);
putrate(rate.v_nexfod, oldrate.v_nexfod, 12, 54, 8);
putfloat (
rate.v_nzfod == 0 ?
0.0
: state != RUN ?
( 100.0 * rate.v_zfod / rate.v_nzfod )
: rate.v_nzfod == oldrate.v_nzfod ?
0.0
:
( 100.0 * (rate.v_zfod-oldrate.v_zfod)
/ (rate.v_nzfod-oldrate.v_nzfod) )
, 13
, 40
, 8
, 2
, 1
);
putfloat (
rate.v_nexfod == 0 ?
0.0
: state != RUN ?
( 100.0 * rate.v_exfod / rate.v_nexfod )
: rate.v_nexfod == oldrate.v_nexfod ?
0.0
:
( 100.0 * (rate.v_exfod-oldrate.v_exfod)
/ (rate.v_nexfod-oldrate.v_nexfod) )
, 13
, 54
, 8
, 2
, 1
);
c = 1;
for (i = 0; i < DK_NDRIVE; i++)
if (dr_state[i] == SOME)
dinfo(i, c++*5);
putint(s.nchcount, 21, 6, 5);
putint(nchtotal.ncs_goodhits, 21, 14, 4);
#define nz(x) ((x) ? (x) : 1)
putfloat(nchtotal.ncs_goodhits * 100.0 / nz(s.nchcount),
21, 19, 4, 0, 1);
putint(nchtotal.ncs_pass2, 21, 28, 4);
putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount),
21, 34, 4, 0, 1);
#undef nz
move(LINES-1,0);
refresh();
waittty(delay);
}
}
/* calculate number of users on the system */
ucount()
{
register int nusers = 0;
while (read(ut, &utmp, sizeof(utmp)))
if (utmp.ut_name[0] != '\0')
nusers++;
lseek(ut, 0L, 0);
return(nusers);
}
float
cputime(indx)
int indx;
{
double t;
register i;
t = 0;
for (i=0; i<CPUSTATES; i++)
t += s.time[i];
if (t == 0.0)
t = 1.0;
return(s.time[indx] * 100.0 / t);
}
void
finish()
{
mvcur(0, COLS-1, LINES-1, 0);
endwin();
exit(0);
}
waittty(period)
{
int inbits = 1 << 0;
struct timeval tv;
tv.tv_usec = 0;
tv.tv_sec = period;
select(32, &inbits, 0, 0, &tv);
if (inbits & (1 << 0))
docmd();
}
void
docmd()
{
int c;
static enum state oldstate;
c = getchar() & 0177;
switch ( c ) {
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
delay = c - '0';
state = TIME;
break;
case 'r':
s1 = s2;
state = RUN;
break;
case 'b':
state = BOOT;
s1 = z;
break;
case 't':
state = TIME;
break;
case 'l': case 'l'&037:
layout();
if (state == STOP)
state = oldstate;
break;
case 'z':
if (state == RUN)
getinfo(&s1, RUN);
else if (state == STOP)
state = oldstate;
break;
case 'q': case 0177:
finish();
/* NOTREACHED */
case ' ': case '0':
if (state == STOP) {
state = oldstate;
break;
}
oldstate = state;
state = STOP;
break;
default:
if (state == STOP)
state = oldstate;
}
}
layout()
{
register i, j;
clear();
mvprintw(1, 5, "users Load");
mvprintw(3, 1, "Mem REAL VIRTUAL ");
mvprintw(4, 1, " Tot Text Tot Text");
mvprintw(5, 1, "Act");
mvprintw(6, 1, "All");
mvprintw(4, 28, "Free");
mvprintw(3, 40, " PAGING SWAPING ");
mvprintw(4, 40, " in out in out ");
mvprintw(5, 40, "count");
mvprintw(6, 40, "pages");
mvprintw( 3, 71, "Csw");
mvprintw( 4, 71, "Trp");
mvprintw( 5, 71, "Sys");
mvprintw( 6, 71, "Int");
mvprintw( 7, 71, "Pdm");
mvprintw( 8, 71, "Flt");
mvprintw( 9, 71, "Scn");
mvprintw(10, 71, "Rev");
mvprintw(8, 40, "Rec It F/S F/F RFL Fre SFr");
mvprintw(11, 49, " zf");
mvprintw(12, 49, "nzf");
mvprintw(13, 49, "%%zf");
mvprintw(11, 63, " xf");
mvprintw(12, 63, "nxf");
mvprintw(13, 63, "%%xf");
mvprintw(15, 5, " Sys . %% User . %% Nice . %% Idle . %%");
mvprintw(15,57, "Procs r p d s w");
mvprintw(16, 5, "| | | | | | | | | | |");
mvprintw(19, 0, "Namei Sys-cache Proc-cache");
mvprintw(20, 0, " Calls hits %% hits %%");
mvprintw( 8, 0, "Discs");
mvprintw( 9, 0, "seeks");
mvprintw(10, 0, "xfers");
mvprintw(11, 0, " blks");
mvprintw(12, 0, " msps");
j = 0;
for (i = 0; i < DK_NDRIVE; i++)
if (dr_state[i] == SOME) {
mvprintw(8, 5 + 5*j, " %3.3s", dr_name[j]);
j++;
}
}
putrate(r, or, l, c, w)
{
if (state != TIME) {
if (state == RUN)
r -= or;
putint((int)((float)r/etime + 0.5), l, c, w);
} else
putint(r, l, c, w);
}
putint(n, l, c, w)
{
char b[128];
move(l, c);
if (n == 0) {
while (w-- > 0)
addch(' ');
return;
}
sprintf(b, "%*d", w, n);
if (strlen(b) > w) {
while (w-- > 0)
addch('*');
return;
}
addstr(b);
}
putfloat(f, l, c, w, d, nz)
float f;
{
char b[128];
move(l, c);
if (nz && f == 0.0) {
while (w-- > 0)
addch(' ');
return;
}
sprintf(b, "%*.*f", w, d, f);
if (strlen(b) > w) {
while (w-- > 0)
addch('*');
return;
}
addstr(b);
}
/*
* Read the drive names out of kmem.
* ARGH ARGH ARGH ARGH !!!!!!!!!!!!
*/
#define steal(where, var) lseek(kmem, where, 0); read(kmem, &var, sizeof var);
read_names()
{
struct mba_device mdev;
register struct mba_device *mp;
struct mba_driver mdrv;
short two_char;
char *cp = (char *) &two_char;
struct uba_device udev, *up;
struct uba_driver udrv;
mp = (struct mba_device *) name[X_MBDINIT].n_value;
up = (struct uba_device *) name[X_UBDINIT].n_value;
if (up == 0)
{
fprintf(stderr, "vsta: Disk init info not in namelist\n");
exit(1);
}
if (mp)
while(1)
{
steal(mp++, mdev);
if (mdev.mi_driver == 0)
break;
if (mdev.mi_dk < 0 || mdev.mi_alive == 0)
continue;
steal(mdev.mi_driver, mdrv);
steal(mdrv.md_dname, two_char);
sprintf(dr_name[mdev.mi_dk], "%c%c%d", cp[0], cp[1], mdev.mi_unit);
}
while(1)
{
steal(up++, udev);
if (udev.ui_driver == 0)
break;
if (udev.ui_dk < 0 || udev.ui_alive == 0)
continue;
steal(udev.ui_driver, udrv);
steal(udrv.ud_dname, two_char);
sprintf(dr_name[udev.ui_dk], "%c%c%d", cp[0], cp[1], udev.ui_unit);
}
}
getinfo(s, st)
struct Info *s;
enum state st;
{
lseek(kmem, (long)name[X_CPTIME].n_value,0);
read(kmem, s->time, sizeof s->time);
if (st != TIME) {
lseek(kmem, (long)name[X_SUM].n_value, 0);
read(kmem, &s->Rate, sizeof &s->Rate);
} else {
lseek(kmem, (long)name[X_RATE].n_value,0);
read(kmem, &s->Rate, sizeof s->Rate);
}
lseek(kmem, (long)name[X_DEFICIT].n_value,0);
read(kmem, deficit, sizeof deficit);
lseek( kmem, (long)name[X_AVENRUN].n_value, 0 );
read( kmem, avenrun, sizeof(avenrun) );
lseek(kmem, (long)name[X_TOTAL].n_value,0);
read(kmem, &s->Total, sizeof s->Total);
lseek(kmem, (long)name[X_DK_BUSY].n_value, 0);
read(kmem, &s->dk_busy, sizeof s->dk_busy);
lseek(kmem, (long)name[X_DK_TIME].n_value, 0);
read(kmem, s->dk_time, sizeof s->dk_time);
lseek(kmem, (long)name[X_DK_XFER].n_value, 0);
read(kmem, s->dk_xfer, sizeof s->dk_xfer);
lseek(kmem, (long)name[X_DK_WDS].n_value, 0);
read(kmem, s->dk_wds, sizeof s->dk_wds);
lseek(kmem, (long)name[X_TK_NIN].n_value, 0);
read(kmem, &s->tk_nin, sizeof s->tk_nin);
lseek(kmem, (long)name[X_TK_NOUT].n_value, 0);
read(kmem, &s->tk_nout, sizeof s->tk_nout);
lseek(kmem, (long)name[X_DK_SEEK].n_value, 0);
read(kmem, s->dk_seek, sizeof s->dk_seek);
lseek(kmem, (long)name[X_NCHSTATS].n_value, 0);
read(kmem, &s->nchstats, sizeof s->nchstats);
}
dinfo(dn, c)
{
double words, atime, itime, xtime;
atime = s.dk_time[dn];
atime /= 60.0;
words = s.dk_wds[dn]*32.0; /* number of words transferred */
xtime = s.dk_mspw[dn]*words; /* transfer time */
itime = atime - xtime; /* time not transferring */
if (xtime < 0)
itime += xtime, xtime = 0;
if (itime < 0)
xtime += itime, itime = 0;
putint((int)((float)s.dk_seek[dn]/etime+0.5), 9, c, 5);
putint((int)((float)s.dk_xfer[dn]/etime+0.5), 10, c, 5);
putint((int)(words/etime/512.0 + 0.5), 11, c, 5);
if (s.dk_seek[dn])
putfloat(itime*1000.0/s.dk_seek[dn], 12, c, 5, 1, 1);
else
putint(0, 12, c, 5);
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.