* Copyright (c) 1983 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
"@(#) Copyright (c) 1983 Regents of the University of California.\n\
static char sccsid
[] = "@(#)vmstat.c 5.1 (Berkeley) %G%";
* Cursed vmstat -- from Robert Elz.
#include <vaxuba/ubavar.h>
#include <vaxmba/mbavar.h>
* These constants define where the major pieces are laid out
#define PROCSROW 13 /* uses 2 rows and 20 cols */
#define NAMEIROW 20 /* uses 3 rows and 38 cols */
#define GRAPHROW 16 /* uses 3 rows and 51 cols */
#define GENSTATROW 14 /* uses 8 rows and 11 cols */
#define INTSROW 2 /* uses all rows to bottom and 17 cols */
#define STATROW 0 /* uses 1 row and 68 cols */
#define PAGEROW 2 /* uses 11 rows and 26 cols */
#define MEMROW 2 /* uses 4 rows and 31 cols */
#define DISKROW 7 /* uses 5 rows and 35 cols */
* Maximum number of times that the clock may no longer advance.
struct forkstat Forkstat
;
float dk_mspw
[DK_NDRIVE
];
struct nchstats nchstats
;
#define nchtotal s.nchstats
#define oldnchtotal s1.nchstats
#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;}
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
};
time_t now
, lastime
, starttime
;
int inttotal
, nextintsrow
;
char *intrnamebuf
, *cp
, *calloc(), *malloc();
switch (c
= argv
[1][0] == '-' ? argv
[1][1] : argv
[1][0]) {
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if ((kmem
= open("/dev/kmem",0)) < 0) {
fprintf(stderr
, "No /dev/kmem \n");
if ((ut
= open("/etc/utmp", 0)) < 0) {
fprintf(stderr
, "No utmp\n");
if (name
[0].n_type
== 0) {
fprintf(stderr
, "No namelist\n");
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
);
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
++)
nintr
= (name
[X_EINTRCNT
].n_value
-
name
[X_INTRCNT
].n_value
) / sizeof(long);
intrloc
= (long *) calloc(nintr
, sizeof(long));
intrname
= (char **) calloc(nintr
, sizeof(long));
intrnamebuf
= malloc(name
[X_EINTRNAMES
].n_value
-
name
[X_INTRNAMES
].n_value
);
if (intrnamebuf
== NULL
|| intrname
== NULL
|| intrloc
== NULL
) {
fprintf(stderr
, "vsta: out of memory\n");
lseek(kmem
, (long)name
[X_INTRNAMES
].n_value
, 0);
read(kmem
, intrnamebuf
, name
[X_EINTRNAMES
].n_value
-
name
[X_INTRNAMES
].n_value
);
for (cp
= intrnamebuf
, i
= 0; i
< nintr
; i
++) {
nextintsrow
= INTSROW
+ 2;
fprintf(stderr
, "vsta: bad state %d\n", state
);
lseek(kmem
, (long)name
[X_BOOTIME
].n_value
, 0);
read(kmem
, &bootime
, sizeof bootime
);
for (loopcnt
= 0; loopcnt
< LOOPMAX
; loopcnt
++) {
strcpy(buf
, ctime(&now
));
for (i
= 0; i
< DK_NDRIVE
; i
++) {
X(dk_xfer
); X(dk_seek
); X(dk_wds
); X(dk_time
);
for(i
= 0; i
< CPUSTATES
; i
++) {
if (etime
< 5.0) /* < 5 ticks - ignore this trash */
for (i
= 0; i
< nintr
; i
++) {
if (nextintsrow
== LINES
)
intrloc
[i
] = nextintsrow
++;
mvprintw(intrloc
[i
], INTSCOL
+ 9, "%-8.8s",
l
= (int)((float)s
.intrcnt
[i
]/etime
+ 0.5);
putint(l
, intrloc
[i
], INTSCOL
, 8);
putint(inttotal
, INTSROW
+ 1, INTSCOL
, 8);
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
;
s1
.nchcount
= s
.nchcount
;
for (c
= 0; c
< CPUSTATES
; c
++) {
l
= (int) ((f2
+ 1.0) / 2.0) - psiz
;
putfloat(f1
, GRAPHROW
, GRAPHCOL
+ 1, 5, 1, 0);
putfloat(f1
, GRAPHROW
, GRAPHCOL
+ 12 * c
,
move(GRAPHROW
+ 2, psiz
);
putint(ucount(), STATROW
, STATCOL
, 3);
putfloat(avenrun
[0], STATROW
, STATCOL
+ 17, 6, 2, 0);
putfloat(avenrun
[1], STATROW
, STATCOL
+ 23, 6, 2, 0);
putfloat(avenrun
[2], STATROW
, STATCOL
+ 29, 6, 2, 0);
mvaddstr(STATROW
, STATCOL
+ 53, buf
);
putint(total
.t_arm
/2, MEMROW
+ 2, MEMCOL
+ 4, 5);
putint(total
.t_armtxt
/2, MEMROW
+ 2, MEMCOL
+ 9, 5);
putint(total
.t_avm
/2, MEMROW
+ 2, MEMCOL
+ 14, 5);
putint(total
.t_avmtxt
/2, MEMROW
+ 2, MEMCOL
+ 19, 5);
putint(total
.t_rm
/2, MEMROW
+ 3, MEMCOL
+ 4, 5);
putint(total
.t_rmtxt
/2, MEMROW
+ 3, MEMCOL
+ 9, 5);
putint(total
.t_vm
/2, MEMROW
+ 3, MEMCOL
+ 14, 5);
putint(total
.t_vmtxt
/2, MEMROW
+ 3, MEMCOL
+ 19, 5);
putint(total
.t_free
/2, MEMROW
+ 2, MEMCOL
+ 26, 5);
putint(total
.t_rq
, PROCSROW
+ 1, PROCSCOL
+ 5, 3);
putint(total
.t_pw
, PROCSROW
+ 1, PROCSCOL
+ 8, 3);
putint(total
.t_dw
, PROCSROW
+ 1, PROCSCOL
+ 11, 3);
putint(total
.t_sl
, PROCSROW
+ 1, PROCSCOL
+ 14, 3);
putint(total
.t_sw
, PROCSROW
+ 1, PROCSCOL
+ 17, 3);
putrate(rate
.v_swtch
, oldrate
.v_swtch
,
GENSTATROW
, GENSTATCOL
, 7);
putrate(rate
.v_trap
, oldrate
.v_trap
,
GENSTATROW
+ 1, GENSTATCOL
, 7);
putrate(rate
.v_syscall
, oldrate
.v_syscall
,
GENSTATROW
+ 2, GENSTATCOL
, 7);
putrate(rate
.v_intr
, oldrate
.v_intr
,
GENSTATROW
+ 3, GENSTATCOL
, 7);
putrate(rate
.v_pdma
, oldrate
.v_pdma
,
GENSTATROW
+ 4, GENSTATCOL
, 7);
putrate(rate
.v_faults
, oldrate
.v_faults
,
GENSTATROW
+ 5, GENSTATCOL
, 7);
putrate(rate
.v_scan
, oldrate
.v_scan
,
GENSTATROW
+ 6, GENSTATCOL
, 7);
putrate(rate
.v_rev
, oldrate
.v_rev
,
GENSTATROW
+ 7, GENSTATCOL
, 7);
putrate(rate
.v_pgin
, oldrate
.v_pgin
, PAGEROW
+ 2,
putrate(rate
.v_pgout
, oldrate
.v_pgout
, PAGEROW
+ 2,
putrate(rate
.v_swpin
, oldrate
.v_swpin
, PAGEROW
+ 2,
putrate(rate
.v_swpout
, oldrate
.v_swpout
, PAGEROW
+ 2,
putrate(rate
.v_pgpgin
, oldrate
.v_pgpgin
, PAGEROW
+ 3,
putrate(rate
.v_pgpgout
, oldrate
.v_pgpgout
, PAGEROW
+ 3,
putrate(rate
.v_pswpin
, oldrate
.v_pswpin
, PAGEROW
+ 3,
putrate(rate
.v_pswpout
, oldrate
.v_pswpout
, PAGEROW
+ 3,
putrate(rate
.v_pgrec
, oldrate
.v_pgrec
, PAGEROW
+ 6, PAGECOL
, 3);
putrate(rate
.v_intrans
, oldrate
.v_intrans
, PAGEROW
+ 6,
putrate(rate
.v_xsfrec
, oldrate
.v_xsfrec
, PAGEROW
+ 6,
putrate(rate
.v_xifrec
, oldrate
.v_xifrec
, PAGEROW
+ 6,
putrate(rate
.v_pgfrec
, oldrate
.v_pgfrec
, PAGEROW
+ 6,
putrate(rate
.v_dfree
, oldrate
.v_dfree
, PAGEROW
+ 6,
putrate(rate
.v_seqfree
, oldrate
.v_seqfree
, PAGEROW
+ 6,
putrate(rate
.v_zfod
, oldrate
.v_zfod
, PAGEROW
+ 8, PAGECOL
, 8);
putrate(rate
.v_nzfod
, oldrate
.v_nzfod
, PAGEROW
+ 9, PAGECOL
, 8);
putrate(rate
.v_exfod
, oldrate
.v_exfod
, PAGEROW
+ 8,
putrate(rate
.v_nexfod
, oldrate
.v_nexfod
, PAGEROW
+ 9,
( 100.0 * rate
.v_zfod
/ rate
.v_nzfod
)
: rate
.v_nzfod
== oldrate
.v_nzfod
?
( 100.0 * (rate
.v_zfod
-oldrate
.v_zfod
)
/ (rate
.v_nzfod
-oldrate
.v_nzfod
) )
( 100.0 * rate
.v_exfod
/ rate
.v_nexfod
)
: rate
.v_nexfod
== oldrate
.v_nexfod
?
( 100.0 * (rate
.v_exfod
-oldrate
.v_exfod
)
/ (rate
.v_nexfod
-oldrate
.v_nexfod
) )
for (i
= 0; i
< DK_NDRIVE
; i
++)
putint(s
.nchcount
, NAMEIROW
+ 2, NAMEICOL
, 9);
putint(nchtotal
.ncs_goodhits
, NAMEIROW
+ 2, NAMEICOL
+ 9, 9);
#define nz(x) ((x) ? (x) : 1)
putfloat(nchtotal
.ncs_goodhits
* 100.0 / nz(s
.nchcount
),
NAMEIROW
+ 2, NAMEICOL
+ 19, 4, 0, 1);
putint(nchtotal
.ncs_pass2
, NAMEIROW
+ 2, NAMEICOL
+ 23, 9);
putfloat(nchtotal
.ncs_pass2
* 100.0 / nz(s
.nchcount
),
NAMEIROW
+ 2, NAMEICOL
+ 34, 4, 0, 1);
mvprintw(2, 10, "THE SYSTEM CLOCK HAS DIED!");
/* calculate number of users on the system */
while (read(ut
, &utmp
, sizeof(utmp
)))
if (utmp
.ut_name
[0] != '\0')
for (i
= 0; i
< CPUSTATES
; i
++)
return(s
.time
[indx
] * 100.0 / t
);
mvcur(0, COLS
-1, LINES
-1, 0);
select(32, &inbits
, 0, 0, &tv
);
static enum state oldstate
;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
mvprintw(STATROW
, STATCOL
+ 4, "users Load");
mvprintw(MEMROW
, MEMCOL
, "Mem REAL VIRTUAL ");
mvprintw(MEMROW
+ 1, MEMCOL
, " Tot Text Tot Text");
mvprintw(MEMROW
+ 2, MEMCOL
, "Act");
mvprintw(MEMROW
+ 3, MEMCOL
, "All");
mvprintw(MEMROW
+ 1, MEMCOL
+ 27, "Free");
mvprintw(PAGEROW
, PAGECOL
, " PAGING SWAPING ");
mvprintw(PAGEROW
+ 1, PAGECOL
, " in out in out ");
mvprintw(PAGEROW
+ 2, PAGECOL
, "count");
mvprintw(PAGEROW
+ 3, PAGECOL
, "pages");
mvprintw(INTSROW
, INTSCOL
, " Interrupts");
mvprintw(INTSROW
+ 1, INTSCOL
+ 9, "total");
mvprintw(GENSTATROW
, GENSTATCOL
+ 8, "Csw");
mvprintw(GENSTATROW
+ 1, GENSTATCOL
+ 8, "Trp");
mvprintw(GENSTATROW
+ 2, GENSTATCOL
+ 8, "Sys");
mvprintw(GENSTATROW
+ 3, GENSTATCOL
+ 8, "Int");
mvprintw(GENSTATROW
+ 4, GENSTATCOL
+ 8, "Pdm");
mvprintw(GENSTATROW
+ 5, GENSTATCOL
+ 8, "Flt");
mvprintw(GENSTATROW
+ 6, GENSTATCOL
+ 8, "Scn");
mvprintw(GENSTATROW
+ 7, GENSTATCOL
+ 8, "Rev");
mvprintw(PAGEROW
+ 5, PAGECOL
, "Rec It F/S F/F RFL Fre SFr");
mvprintw(PAGEROW
+ 8, PAGECOL
+ 9, " zf");
mvprintw(PAGEROW
+ 9, PAGECOL
+ 9, "nzf");
mvprintw(PAGEROW
+ 10, PAGECOL
+ 9, "%%zf");
mvprintw(PAGEROW
+ 8, PAGECOL
+ 23, " xf");
mvprintw(PAGEROW
+ 9, PAGECOL
+ 23, "nxf");
mvprintw(PAGEROW
+ 10, PAGECOL
+ 23, "%%xf");
mvprintw(GRAPHROW
, GRAPHCOL
,
" . %% Sys . %% User . %% Nice . %% Idle");
mvprintw(PROCSROW
, PROCSCOL
, "Procs r p d s w");
mvprintw(GRAPHROW
+ 1, GRAPHCOL
,
"| | | | | | | | | | |");
mvprintw(NAMEIROW
, NAMEICOL
, "Namei Sys-cache Proc-cache");
mvprintw(NAMEIROW
+ 1, NAMEICOL
,
" Calls hits %% hits %%");
mvprintw(DISKROW
, DISKCOL
, "Discs");
mvprintw(DISKROW
+ 1, DISKCOL
, "seeks");
mvprintw(DISKROW
+ 2, DISKCOL
, "xfers");
mvprintw(DISKROW
+ 3, DISKCOL
, " blks");
mvprintw(DISKROW
+ 4, DISKCOL
, " msps");
for (i
= 0; i
< DK_NDRIVE
; i
++)
if (dr_state
[i
] == SOME
) {
mvprintw(DISKROW
, DISKCOL
+ 5 + 5 * j
,
for (i
= 0; i
< nintr
; i
++) {
mvprintw(intrloc
[i
], INTSCOL
+ 9, "%-8.8s", intrname
[i
]);
putint((int)((float)r
/etime
+ 0.5), l
, c
, w
);
putfloat(f
, l
, c
, w
, d
, nz
)
sprintf(b
, "%*.*f", w
, d
, f
);
* Read the drive names out of kmem.
* ARGH ARGH ARGH ARGH !!!!!!!!!!!!
#define steal(where, var) lseek(kmem, where, 0); read(kmem, &var, sizeof var);
register struct mba_device
*mp
;
char *cp
= (char *) &two_char
;
struct uba_device udev
, *up
;
mp
= (struct mba_device
*) name
[X_MBDINIT
].n_value
;
up
= (struct uba_device
*) name
[X_UBDINIT
].n_value
;
fprintf(stderr
, "vsta: Disk init info not in namelist\n");
if (mdev
.mi_dk
< 0 || mdev
.mi_alive
== 0)
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
);
if (udev
.ui_dk
< 0 || udev
.ui_alive
== 0)
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
);
lseek(kmem
, (long)name
[X_CPTIME
].n_value
,0);
read(kmem
, s
->time
, sizeof s
->time
);
lseek(kmem
, (long)name
[X_SUM
].n_value
, 0);
read(kmem
, &s
->Rate
, sizeof &s
->Rate
);
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
);
lseek(kmem
, (long)name
[X_INTRCNT
].n_value
, 0);
read(kmem
, s
->intrcnt
, nintr
* sizeof (long));
s
->intrcnt
= (long *) malloc(nintr
* sizeof(long));
if (s
->intrcnt
== NULL
) {
fprintf(stderr
, "vsta: out of memory\n");
register int i
, *fip
= from
->intrcnt
, *tip
= to
->intrcnt
;
for (i
= 0; i
< nintr
; i
++)
double words
, atime
, itime
, xtime
;
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 */
itime
+= xtime
, xtime
= 0;
xtime
+= itime
, itime
= 0;
putint((int)((float)s
.dk_seek
[dn
]/etime
+0.5), DISKROW
+ 1, c
, 5);
putint((int)((float)s
.dk_xfer
[dn
]/etime
+0.5), DISKROW
+ 2, c
, 5);
putint((int)(words
/etime
/512.0 + 0.5), DISKROW
+ 3, c
, 5);
putfloat(itime
*1000.0/s
.dk_seek
[dn
], DISKROW
+ 4, c
, 5, 1, 1);
putint(0, DISKROW
+ 4, c
, 5);