void
show_vmstat_top(vmtotal_t *Total, uvmexp_sysctl_t *uvm, uvmexp_sysctl_t *uvm1)
{
float f1, f2;
int psiz;
int i, l, c;
struct {
struct uvmexp_sysctl *uvmexp;
} us, us1;
us.uvmexp = uvm;
us1.uvmexp = uvm1;
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_rq - 1, PROCSROW + 1, PROCSCOL + 3, 3);
putint(Total->t_dw, PROCSROW + 1, PROCSCOL + 6, 3);
putint(Total->t_sl, PROCSROW + 1, PROCSCOL + 9, 3);
PUTRATE(us, us1, uvmexp->swtch, GENSTATROW + 1, GENSTATCOL - 1, 7);
PUTRATE(us, us1, uvmexp->traps, GENSTATROW + 1, GENSTATCOL + 7, 6);
PUTRATE(us, us1, uvmexp->syscalls, GENSTATROW + 1, GENSTATCOL + 14, 6);
PUTRATE(us, us1, uvmexp->intrs, GENSTATROW + 1, GENSTATCOL + 21, 5);
PUTRATE(us, us1, uvmexp->softs, GENSTATROW + 1, GENSTATCOL + 27, 6);
PUTRATE(us, us1, uvmexp->faults, GENSTATROW + 1, GENSTATCOL + 34, 6);
/* Last CPU state not calculated yet. */
for (f2 = 0.0, psiz = 0, c = 0; c < CPUSTATES; c++) {
i = cpuorder[c];
f1 = cputime(i);
f2 += f1;
l = (int) ((f2 + 1.0) / 2.0) - psiz;
if (c == 0)
putfloat(f1, GRAPHROW, GRAPHCOL + 1, 5, 1, 0);
else
putfloat(f1, GRAPHROW, GRAPHCOL + 10 * c + 1, 5, 1, 0);
mvhline(GRAPHROW + 2, psiz, cpuchar[c], l);
psiz += l;
}
PUTRATE(us, us1, uvmexp->pageins, PAGEROW + 2, PAGECOL + 5, 5);
PUTRATE(us, us1, uvmexp->pdpageouts, PAGEROW + 2, PAGECOL + 10, 5);
PUTRATE(us, us1, uvmexp->pgswapin, PAGEROW + 3, PAGECOL + 5, 5);
PUTRATE(us, us1, uvmexp->pgswapout, PAGEROW + 3, PAGECOL + 10, 5);
}
static void
dinfo(int dn, int r, int c)
{
double atime;
#define ADV if (disk_horiz) r++; else c += DISKCOLWIDTH
mvprintw(r, c, "%*.*s", DISKCOLWIDTH, DISKCOLWIDTH, dr_name[dn]);
ADV;
putint((int)(cur.seek[dn]/etime+0.5), r, c, DISKCOLWIDTH);
ADV;
putint((int)((cur.rxfer[dn]+cur.wxfer[dn])/etime+0.5),
r, c, DISKCOLWIDTH);
ADV;
puthumanint((cur.rbytes[dn] + cur.wbytes[dn]) / etime + 0.5,
r, c, DISKCOLWIDTH);
ADV;
/* time busy in disk activity */
atime = cur.time[dn].tv_sec + cur.time[dn].tv_usec / 1000000.0;
atime = atime * 100.0 / etime;
if (atime >= 100)
putint(100, r, c, DISKCOLWIDTH);
else
putfloat(atime, r, c, DISKCOLWIDTH, 1, 1);
}
static void
dinfo(int dn, int c)
{
double words, atime;
c += DISKCOL;
/* time busy in disk activity */
atime = (double)cur.dk_time[dn].tv_sec +
((double)cur.dk_time[dn].tv_usec / (double)1000000);
/* # of K transferred */
words = (cur.dk_rbytes[dn] + cur.dk_wbytes[dn]) / 1024.0;
putint((int)((float)cur.dk_seek[dn]/etime+0.5), DISKROW + 1, c, 5);
putint((int)((float)(cur.dk_rxfer[dn] + cur.dk_wxfer[dn])/etime+0.5),
DISKROW + 2, c, 5);
putintmk((int)(words/etime + 0.5), DISKROW + 3, c, 5);
putfloat(atime/etime, DISKROW + 4, c, 5, 1, 1);
}
void
showkre(void)
{
float f1, f2;
int psiz;
int i, lc;
long inttotal;
long l;
static int failcnt = 0;
double total_time;
etime = 0;
CP_UPDATE(cp_time.cp_user);
CP_UPDATE(cp_time.cp_nice);
CP_UPDATE(cp_time.cp_sys);
CP_UPDATE(cp_time.cp_intr);
CP_UPDATE(cp_time.cp_idle);
total_time = etime;
if (total_time == 0.0)
total_time = 1.0;
if (etime < 100000.0) { /* < 100ms ignore this trash */
if (failcnt++ >= MAXFAIL) {
clear();
mvprintw(2, 10, "The alternate system clock has died!");
mvprintw(3, 10, "Reverting to ``pigs'' display.");
move(CMDLINE, 0);
refresh();
failcnt = 0;
sleep(5);
command("pigs");
}
return;
}
failcnt = 0;
etime /= 1000000.0;
etime /= ncpu;
if (etime == 0)
etime = 1;
inttotal = 0;
for (i = 0; i < nintr; i++) {
if (s.intrcnt[i] == 0)
continue;
if (intrloc[i] == 0) {
if (nextintsrow == LINES)
continue;
intrloc[i] = nextintsrow++;
mvprintw(intrloc[i], INTSCOL + 9, "%-10.10s",
intrname[i]);
}
X(intrcnt);
l = (long)((float)s.intrcnt[i]/etime + 0.5);
inttotal += l;
put64(l, intrloc[i], INTSCOL + 2, 6, 'D');
}
put64(inttotal, INTSROW + 1, INTSCOL + 2, 6, 'D');
Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss);
Z(ncs_longhits); Z(ncs_longmiss); Z(ncs_neghits);
s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits +
nchtotal.ncs_miss + nchtotal.ncs_neghits;
s.nchpathcount = nchtotal.ncs_longhits + nchtotal.ncs_longmiss;
if (state == TIME) {
s1.nchcount = s.nchcount;
s1.nchpathcount = s.nchpathcount;
}
psiz = 0;
f2 = 0.0;
for (lc = 0; lc < CPUSTATES; lc++) {
uint64_t val = *(uint64_t *)(((uint8_t *)&s.cp_time) +
cpuoffsets[lc]);
f1 = 100.0 * val / total_time;
f2 += f1;
l = (int) ((f2 + 1.0) / 2.0) - psiz;
if (f1 > 99.9)
f1 = 99.9; /* no room to display 100.0 */
putfloat(f1, GRAPHROW, GRAPHCOL + 10 * lc, 4, 1, 0);
move(GRAPHROW + 2, psiz);
psiz += l;
while (l-- > 0)
addch(cpuchar[lc]);
}
put64(ucount(), STATROW, STATCOL, 3, 'D');
putfloat(avenrun[0], STATROW, STATCOL + 18, 6, 2, 0);
putfloat(avenrun[1], STATROW, STATCOL + 25, 6, 2, 0);
putfloat(avenrun[2], STATROW, STATCOL + 32, 6, 2, 0);
mvaddstr(STATROW, STATCOL + 53, buf);
#define pgtokb(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size / 1024)
#define pgtomb(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size / (1024 * 1024))
#define pgtob(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size)
put64(pgtob(total.t_arm), MEMROW + 2, MEMCOL + 4, 6, 0);
put64(pgtob(total.t_armshr), MEMROW + 2, MEMCOL + 11, 6, 0);
put64(pgtob(total.t_avm), MEMROW + 2, MEMCOL + 19, 6, 0);
put64(pgtob(total.t_avmshr), MEMROW + 2, MEMCOL + 26, 6, 0);
put64(pgtob(total.t_rm), MEMROW + 3, MEMCOL + 4, 6, 0);
put64(pgtob(total.t_rmshr), MEMROW + 3, MEMCOL + 11, 6, 0);
put64(pgtob(total.t_vm), MEMROW + 3, MEMCOL + 19, 6, 0);
put64(pgtob(total.t_vmshr), MEMROW + 3, MEMCOL + 26, 6, 0);
put64(pgtob(total.t_free), MEMROW + 2, MEMCOL + 34, 6, 0);
put64(total.t_rq - 1, PROCSROW + 1, PROCSCOL + 0, 3, 'D');
put64(total.t_pw, PROCSROW + 1, PROCSCOL + 3, 3, 'D');
put64(total.t_dw, PROCSROW + 1, PROCSCOL + 6, 3, 'D');
put64(total.t_sl, PROCSROW + 1, PROCSCOL + 9, 3, 'D');
put64(total.t_sw, PROCSROW + 1, PROCSCOL + 12, 3, 'D');
if (extended_vm_stats == 0) {
PUTRATE(Vmm.v_zfod, VMSTATROW + 0, VMSTATCOL, 7);
}
PUTRATE(Vmm.v_cow_faults, VMSTATROW + 1, VMSTATCOL, 7);
put64(pgtob(vms.v_wire_count), VMSTATROW + 2, VMSTATCOL, 7, 0);
put64(pgtob(vms.v_active_count), VMSTATROW + 3, VMSTATCOL, 7, 0);
put64(pgtob(vms.v_inactive_count), VMSTATROW + 4, VMSTATCOL, 7, 0);
put64(pgtob(vms.v_cache_count), VMSTATROW + 5, VMSTATCOL, 7, 0);
put64(pgtob(vms.v_free_count), VMSTATROW + 6, VMSTATCOL, 7, 0);
PUTRATE(Vmm.v_dfree, VMSTATROW + 7, VMSTATCOL, 7);
PUTRATE(Vmm.v_pfree, VMSTATROW + 8, VMSTATCOL, 7);
PUTRATE(Vmm.v_reactivated, VMSTATROW + 9, VMSTATCOL, 7);
PUTRATE(Vmm.v_pdwakeups, VMSTATROW + 10, VMSTATCOL, 7);
PUTRATE(Vmm.v_pdpages, VMSTATROW + 11, VMSTATCOL, 7);
PUTRATE(Vmm.v_intrans, VMSTATROW + 12, VMSTATCOL, 7);
if (extended_vm_stats) {
PUTRATE(Vmm.v_zfod, VMSTATROW + 11, VMSTATCOL - 16, 9);
PUTRATE(Vmm.v_ozfod, VMSTATROW + 12, VMSTATCOL - 16, 9);
#define nz(x) ((x) ? (x) : 1)
put64((s.Vmm.v_zfod - s.Vmm.v_ozfod) * 100 / nz(s.Vmm.v_zfod),
VMSTATROW + 13, VMSTATCOL - 16, 9, 'D');
#undef nz
PUTRATE(Vmm.v_tfree, VMSTATROW + 14, VMSTATCOL - 16, 9);
}
put64(s.bufspace, VMSTATROW + 13, VMSTATCOL, 7, 0);
put64(s.dirtybufspace/1024, VMSTATROW + 14, VMSTATCOL, 7, 'k');
put64(s.desiredvnodes, VMSTATROW + 15, VMSTATCOL, 7, 'D');
put64(s.numvnodes, VMSTATROW + 16, VMSTATCOL, 7, 'D');
put64(s.freevnodes, VMSTATROW + 17, VMSTATCOL, 7, 'D');
PUTRATE(Vmm.v_vnodein, PAGEROW + 2, PAGECOL + 6, 4);
PUTRATE(Vmm.v_vnodeout, PAGEROW + 2, PAGECOL + 11, 4);
PUTRATE(Vmm.v_swapin, PAGEROW + 2, PAGECOL + 18, 4);
PUTRATE(Vmm.v_swapout, PAGEROW + 2, PAGECOL + 23, 4);
PUTRATE(Vmm.v_vnodepgsin, PAGEROW + 3, PAGECOL + 6, 4);
PUTRATE(Vmm.v_vnodepgsout, PAGEROW + 3, PAGECOL + 11, 4);
PUTRATE(Vmm.v_swappgsin, PAGEROW + 3, PAGECOL + 18, 4);
PUTRATE(Vmm.v_swappgsout, PAGEROW + 3, PAGECOL + 23, 4);
PUTRATE(Vmm.v_swtch, GENSTATROW + 1, GENSTATCOL + 1, 4);
PUTRATE(Vmm.v_trap, GENSTATROW + 1, GENSTATCOL + 6, 4);
PUTRATE(Vmm.v_syscall, GENSTATROW + 1, GENSTATCOL + 11, 4);
PUTRATE(Vmm.v_intr, GENSTATROW + 1, GENSTATCOL + 16, 4);
PUTRATE(Vmm.v_soft, GENSTATROW + 1, GENSTATCOL + 21, 4);
PUTRATE(Vmm.v_vm_faults, GENSTATROW + 1, GENSTATCOL + 26, 4);
mvprintw(DISKROW, DISKCOL + 5, " ");
for (i = 0, lc = 0; i < num_devices && lc < MAXDRIVES; i++)
if (dev_select[i].selected) {
char tmpstr[80];
sprintf(tmpstr, "%s%d", dev_select[i].device_name,
dev_select[i].unit_number);
mvprintw(DISKROW, DISKCOL + 5 + 6 * lc,
" %5.5s", tmpstr);
switch(state) {
case TIME:
dinfo(i, ++lc, &cur, &last);
break;
case RUN:
dinfo(i, ++lc, &cur, &run);
break;
case BOOT:
dinfo(i, ++lc, &cur, NULL);
break;
}
}
#define nz(x) ((x) ? (x) : 1)
put64(s.nchpathcount, NAMEIROW + 1, NAMEICOL + 3, 9, 'D');
put64(nchtotal.ncs_longhits, NAMEIROW + 1, NAMEICOL + 12, 7, 'D');
putfloat(nchtotal.ncs_longhits * 100.0 / nz(s.nchpathcount),
NAMEIROW + 1, NAMEICOL + 19, 4, 0, 0);
putfloat((double)s.nchcount / nz(s.nchpathcount),
NAMEIROW + 1, NAMEICOL + 27, 5, 2, 1);
#undef nz
}
void
showvmstat(void)
{
int inttotal;
int i, l, r, c;
static int failcnt = 0;
static int relabel = 0;
static int last_disks = 0;
static char pigs[] = "pigs";
if (relabel) {
labelvmstat();
relabel = 0;
}
cpuswap();
if (display_mode == TIME) {
drvswap();
etime = cur.cp_etime;
/* < 5 ticks - ignore this trash */
if ((etime * hertz) < 1.0) {
if (failcnt++ <= MAXFAIL)
return;
clear();
mvprintw(2, 10, "The alternate system clock has died!");
mvprintw(3, 10, "Reverting to ``pigs'' display.");
move(CMDLINE, 0);
refresh();
failcnt = 0;
sleep(5);
command(pigs);
return;
}
} else
etime = 1.0;
show_vmstat_top(&s.Total, &s.uvmexp, &s1.uvmexp);
/* Memory totals */
#define pgtokb(pg) ((pg) * (s.uvmexp.pagesize / 1024))
putint(pgtokb(s.uvmexp.active), MEMROW + 2, MEMCOL + 6, 9);
putint(pgtokb(s.uvmexp.active + s.uvmexp.swpginuse), /* XXX */
MEMROW + 2, MEMCOL + 16, 9);
putint(pgtokb(s.uvmexp.npages - s.uvmexp.free),
MEMROW + 3, MEMCOL + 6, 9);
putint(pgtokb(s.uvmexp.npages - s.uvmexp.free + s.uvmexp.swpginuse),
MEMROW + 3, MEMCOL + 16, 9);
putint(pgtokb(s.uvmexp.free), MEMROW + 2, MEMCOL + 26, 9);
putint(pgtokb(s.uvmexp.free + s.uvmexp.swpages - s.uvmexp.swpginuse),
MEMROW + 3, MEMCOL + 26, 9);
#undef pgtokb
/* Namei cache */
Z(s, s1, ncs_goodhits); Z(s, s1, ncs_badhits); Z(s, s1, ncs_miss);
Z(s, s1, ncs_long); Z(s, s1, ncs_pass2); Z(s, s1, ncs_2passes);
s.nchcount = s.nchstats.ncs_goodhits + s.nchstats.ncs_badhits +
s.nchstats.ncs_miss + s.nchstats.ncs_long +
s.nchstats.ncs_pass2 + s.nchstats.ncs_2passes;
if (display_mode == TIME)
s1.nchcount = s.nchcount;
putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 9);
putint(s.nchstats.ncs_goodhits, NAMEIROW + 2, NAMEICOL + 9, 9);
#define nz(x) ((x) ? (x) : 1)
putfloat(s.nchstats.ncs_goodhits * 100.0 / nz(s.nchcount),
NAMEIROW + 2, NAMEICOL + 19, 4, 0, 1);
putint(s.nchstats.ncs_pass2, NAMEIROW + 2, NAMEICOL + 23, 9);
putfloat(s.nchstats.ncs_pass2 * 100.0 / nz(s.nchcount),
NAMEIROW + 2, NAMEICOL + 34, 4, 0, 1);
#undef nz
/* Disks */
for (l = 0, i = 0, r = DISKROW, c = DISKCOL;
i < (int)ndrive; i++) {
if (!drv_select[i])
continue;
if (disk_horiz)
c += DISKCOLWIDTH;
else
r++;
if (c + DISKCOLWIDTH > DISKCOLEND) {
if (disk_horiz && LINES - 1 - DISKROW >
(DISKCOLEND - DISKCOL) / DISKCOLWIDTH) {
disk_horiz = 0;
relabel = 1;
}
break;
}
if (r >= LINES - 1) {
if (!disk_horiz && LINES - 1 - DISKROW <
(DISKCOLEND - DISKCOL) / DISKCOLWIDTH) {
disk_horiz = 1;
relabel = 1;
}
break;
}
l++;
dinfo(i, r, c);
}
/* blank out if we lost any disks */
for (i = l; i < last_disks; i++) {
int j;
if (disk_horiz)
c += DISKCOLWIDTH;
else
r++;
for (j = 0; j < 5; j++) {
if (disk_horiz)
mvprintw(r+j, c, "%*s", DISKCOLWIDTH, "");
else
mvprintw(r, c+j*DISKCOLWIDTH, "%*s", DISKCOLWIDTH, "");
}
}
last_disks = l;
/* Interrupts */
failcnt = 0;
inttotal = 0;
for (i = 0; i < nintr; i++) {
if (s.intrcnt[i] == 0)
continue;
if (intrloc[i] == 0) {
if (nextintsrow == LINES)
continue;
intrloc[i] = nextintsrow++;
mvprintw(intrloc[i], INTSCOL + 9, "%-.*s",
INTSCOLEND - (INTSCOL + 9), intrname[i]);
}
X(s, s1, intrcnt);
l = (int)((float)s.intrcnt[i]/etime + 0.5);
inttotal += l;
putint(l, intrloc[i], INTSCOL, 8);
}
for (i = 0; i < nevcnt; i++) {
if (s.evcnt[i] == 0)
continue;
if (ie_head[i].ie_loc == 0) {
if (nextintsrow == LINES)
continue;
ie_head[i].ie_loc = nextintsrow++;
print_ie_title(i);
}
X(s, s1, evcnt);
l = (int)((float)s.evcnt[i]/etime + 0.5);
inttotal += l;
putint(l, ie_head[i].ie_loc, INTSCOL, 8);
}
putint(inttotal, INTSROW, INTSCOL, 8);
PUTRATE(s, s1, uvmexp.forks, VMSTATROW + 0, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.forks_ppwait, VMSTATROW + 1, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.forks_sharevm, VMSTATROW + 2, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.fltpgwait, VMSTATROW + 3, VMSTATCOL + 4, 5);
PUTRATE(s, s1, uvmexp.fltrelck, VMSTATROW + 4, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.fltrelckok, VMSTATROW + 5, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.fltnoram, VMSTATROW + 6, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.fltamcopy, VMSTATROW + 7, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.flt_prcopy, VMSTATROW + 8, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.flt_przero, VMSTATROW + 9, VMSTATCOL + 3, 6);
PUTRATE(s, s1, uvmexp.flt_acow, VMSTATROW + 10, VMSTATCOL, 9);
putint(s.uvmexp.freemin, VMSTATROW + 11, VMSTATCOL, 9);
putint(s.uvmexp.freetarg, VMSTATROW + 12, VMSTATCOL, 9);
putint(s.uvmexp.inactarg, VMSTATROW + 13, VMSTATCOL, 9);
putint(s.uvmexp.wired, VMSTATROW + 14, VMSTATCOL, 9);
PUTRATE(s, s1, uvmexp.pdfreed, VMSTATROW + 15, VMSTATCOL, 9);
if (LINES - 1 > VMSTATROW + 16)
PUTRATE(s, s1, uvmexp.pdscans, VMSTATROW + 16, VMSTATCOL, 9);
}
void
showkre(void)
{
float f1, f2;
int psiz, inttotal;
int i, l, lc;
static int failcnt = 0;
etime = 0;
for(i = 0; i < CPUSTATES; i++) {
X(time);
Q(cp_time);
etime += s.time[i];
}
if (etime < 5.0) { /* < 5 ticks - ignore this trash */
if (failcnt++ >= MAXFAIL) {
clear();
mvprintw(2, 10, "The alternate system clock has died!");
mvprintw(3, 10, "Reverting to ``pigs'' display.");
move(CMDLINE, 0);
refresh();
failcnt = 0;
sleep(5);
command("pigs");
}
return;
}
failcnt = 0;
etime /= hertz;
etime /= ncpu;
inttotal = 0;
for (i = 0; i < nintr; i++) {
if (s.intrcnt[i] == 0)
continue;
X(intrcnt);
l = (int)((float)s.intrcnt[i]/etime + 0.5);
inttotal += l;
if (intrloc[i] == 0) {
if (nextintsrow == LINES)
continue;
intrloc[i] = nextintsrow++;
mvprintw(intrloc[i], INTSCOL + 6, "%-10.10s",
intrname[i]);
}
putint(l, intrloc[i], INTSCOL, 5);
}
putint(inttotal, INTSROW + 1, INTSCOL, 5);
Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss);
Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes); Z(ncs_neghits);
s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits +
nchtotal.ncs_miss + nchtotal.ncs_long + nchtotal.ncs_neghits;
if (state == TIME)
s1.nchcount = s.nchcount;
psiz = 0;
f2 = 0.0;
for (lc = 0; lc < CPUSTATES; lc++) {
i = cpuorder[lc];
f1 = cputime(i);
f2 += f1;
l = (int) ((f2 + 1.0) / 2.0) - psiz;
putfloat(f1, GRAPHROW, GRAPHCOL + 10 * lc, 4, 1, 0);
move(GRAPHROW + 2, psiz);
psiz += l;
while (l-- > 0)
addch(cpuchar[lc]);
}
putint(ucount(), STATROW, STATCOL, 5);
putfloat(avenrun[0], STATROW, STATCOL + 20, 5, 2, 0);
putfloat(avenrun[1], STATROW, STATCOL + 26, 5, 2, 0);
putfloat(avenrun[2], STATROW, STATCOL + 32, 5, 2, 0);
mvaddstr(STATROW, STATCOL + 55, buf);
#define pgtokb(pg) ((pg) * (s.v_page_size / 1024))
putfloat(100.0 * (v_page_count - total.t_free) / v_page_count,
STATROW + 1, STATCOL + 15, 2, 0, 1);
putfloat(100.0 * s.v_kmem_map_size / kmem_size,
STATROW + 1, STATCOL + 22, 2, 0, 1);
putint(pgtokb(total.t_arm), MEMROW + 2, MEMCOL + 4, 7);
putint(pgtokb(total.t_armshr), MEMROW + 2, MEMCOL + 12, 7);
putint(pgtokb(total.t_avm), MEMROW + 2, MEMCOL + 20, 8);
putint(pgtokb(total.t_avmshr), MEMROW + 2, MEMCOL + 29, 8);
putint(pgtokb(total.t_rm), MEMROW + 3, MEMCOL + 4, 7);
putint(pgtokb(total.t_rmshr), MEMROW + 3, MEMCOL + 12, 7);
putint(pgtokb(total.t_vm), MEMROW + 3, MEMCOL + 20, 8);
putint(pgtokb(total.t_vmshr), MEMROW + 3, MEMCOL + 29, 8);
putint(pgtokb(total.t_free), MEMROW + 2, MEMCOL + 38, 7);
putint(total.t_rq - 1, PROCSROW + 2, PROCSCOL, 3);
putint(total.t_pw, PROCSROW + 2, PROCSCOL + 4, 3);
putint(total.t_dw, PROCSROW + 2, PROCSCOL + 8, 3);
putint(total.t_sl, PROCSROW + 2, PROCSCOL + 12, 3);
putint(total.t_sw, PROCSROW + 2, PROCSCOL + 16, 3);
PUTRATE(v_io_faults, VMSTATROW, VMSTATCOL + 2, 8 - 2);
PUTRATE(v_cow_faults, VMSTATROW + 1, VMSTATCOL + 2, 8 - 2);
PUTRATE(v_zfod, VMSTATROW + 2, VMSTATCOL + 2, 8 - 2);
PUTRATE(v_ozfod, VMSTATROW + 3, VMSTATCOL, 8);
putint(s.v_zfod != 0 ? (int)(s.v_ozfod * 100.0 / s.v_zfod) : 0,
VMSTATROW + 4, VMSTATCOL + 1, 8 - 1);
PUTRATE(v_dfree, VMSTATROW + 5, VMSTATCOL + 2, 8 - 2);
PUTRATE(v_pfree, VMSTATROW + 6, VMSTATCOL + 2, 8 - 2);
PUTRATE(v_tfree, VMSTATROW + 7, VMSTATCOL, 8);
PUTRATE(v_reactivated, VMSTATROW + 8, VMSTATCOL, 8);
PUTRATE(v_pdwakeups, VMSTATROW + 9, VMSTATCOL, 8);
PUTRATE(v_pdpages, VMSTATROW + 10, VMSTATCOL, 8);
PUTRATE(v_intrans, VMSTATROW + 11, VMSTATCOL, 8);
putint(pgtokb(s.v_wire_count), VMSTATROW + 12, VMSTATCOL, 8);
putint(pgtokb(s.v_active_count), VMSTATROW + 13, VMSTATCOL, 8);
putint(pgtokb(s.v_inactive_count), VMSTATROW + 14, VMSTATCOL, 8);
putint(pgtokb(s.v_free_count), VMSTATROW + 16, VMSTATCOL, 8);
if (LINES - 1 > VMSTATROW + 17)
putint(s.bufspace / 1024, VMSTATROW + 17, VMSTATCOL, 8);
PUTRATE(v_vnodein, PAGEROW + 2, PAGECOL + 6, 5);
PUTRATE(v_vnodeout, PAGEROW + 2, PAGECOL + 12, 5);
PUTRATE(v_swapin, PAGEROW + 2, PAGECOL + 19, 5);
PUTRATE(v_swapout, PAGEROW + 2, PAGECOL + 25, 5);
PUTRATE(v_vnodepgsin, PAGEROW + 3, PAGECOL + 6, 5);
PUTRATE(v_vnodepgsout, PAGEROW + 3, PAGECOL + 12, 5);
PUTRATE(v_swappgsin, PAGEROW + 3, PAGECOL + 19, 5);
PUTRATE(v_swappgsout, PAGEROW + 3, PAGECOL + 25, 5);
PUTRATE(v_swtch, GENSTATROW + 1, GENSTATCOL, 4);
PUTRATE(v_trap, GENSTATROW + 1, GENSTATCOL + 5, 4);
PUTRATE(v_syscall, GENSTATROW + 1, GENSTATCOL + 10, 4);
PUTRATE(v_intr, GENSTATROW + 1, GENSTATCOL + 15, 4);
PUTRATE(v_soft, GENSTATROW + 1, GENSTATCOL + 20, 4);
PUTRATE(v_vm_faults, GENSTATROW + 1, GENSTATCOL + 25, 4);
for (i = 0, lc = 0; i < num_devices && lc < MAXDRIVES; i++)
if (dev_select[i].selected) {
switch(state) {
case TIME:
dinfo(i, ++lc, &cur, &last);
break;
case RUN:
dinfo(i, ++lc, &cur, &run);
break;
case BOOT:
dinfo(i, ++lc, &cur, NULL);
break;
}
}
putint(s.numdirtybuffers, VNSTATROW, VNSTATCOL, 7);
putint(s.desiredvnodes, VNSTATROW + 1, VNSTATCOL, 7);
putint(s.numvnodes, VNSTATROW + 2, VNSTATCOL, 7);
putint(s.freevnodes, VNSTATROW + 3, VNSTATCOL, 7);
putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 8);
putint((nchtotal.ncs_goodhits + nchtotal.ncs_neghits),
NAMEIROW + 2, NAMEICOL + 9, 7);
#define nz(x) ((x) ? (x) : 1)
putfloat((nchtotal.ncs_goodhits+nchtotal.ncs_neghits) *
100.0 / nz(s.nchcount),
NAMEIROW + 2, NAMEICOL + 17, 3, 0, 1);
putint(nchtotal.ncs_pass2, NAMEIROW + 2, NAMEICOL + 21, 7);
putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount),
NAMEIROW + 2, NAMEICOL + 29, 3, 0, 1);
#undef nz
}
void
showkre(void)
{
float f1, f2;
int psiz;
u_int64_t inttotal, intcnt;
int i, l, c;
static int failcnt = 0, first_run = 0;
if (state == TIME) {
if (!first_run) {
first_run = 1;
return;
}
}
etime = 0;
for (i = 0; i < CPUSTATES; i++) {
X(time);
etime += s.time[i];
}
if (etime < 5.0) { /* < 5 ticks - ignore this trash */
if (failcnt++ >= MAXFAIL) {
error("The alternate system clock has died!");
failcnt = 0;
}
return;
}
failcnt = 0;
etime /= hertz;
inttotal = 0;
for (i = 0; i < nintr; i++) {
if (s.intrcnt[i] == 0)
continue;
if (intrloc[i] == 0) {
if (nextintsrow == LINES)
continue;
intrloc[i] = nextintsrow++;
mvprintw(intrloc[i], INTSCOL + 9, "%-8.8s",
intrname[i]);
}
t = intcnt = s.intrcnt[i];
s.intrcnt[i] -= s1.intrcnt[i];
intcnt = (u_int64_t)((float)s.intrcnt[i]/etime + 0.5);
inttotal += intcnt;
putuint64(intcnt, intrloc[i], INTSCOL, 8);
}
putuint64(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;
putint(sum.ifc_ip, LINES - 3, INTSCOL, 8);
putint(sum.ifc_op, LINES - 2, INTSCOL, 8);
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, GRAPHROW, GRAPHCOL + 1 + (10 * c), 5, 1, 0);
move(GRAPHROW + 2, psiz);
psiz += l;
while (l-- > 0)
addch(cpuchar[c]);
}
#define pgtokb(pg) ((pg) * (s.uvmexp.pagesize / 1024))
putint(pgtokb(s.uvmexp.active), MEMROW + 2, MEMCOL + 7, 8);
putint(pgtokb(s.uvmexp.active + s.uvmexp.swpginuse), /* XXX */
MEMROW + 2, MEMCOL + 17, 8);
putint(pgtokb(s.uvmexp.npages - s.uvmexp.free), MEMROW + 3, MEMCOL + 7, 8);
putint(pgtokb(s.uvmexp.npages - s.uvmexp.free + s.uvmexp.swpginuse),
MEMROW + 3, MEMCOL + 17, 8);
putint(pgtokb(s.uvmexp.free), MEMROW + 2, MEMCOL + 26, 8);
putint(pgtokb(s.uvmexp.free + s.uvmexp.swpages - s.uvmexp.swpginuse),
MEMROW + 3, MEMCOL + 26, 8);
putint(total.t_rq - 1, PROCSROW + 1, PROCSCOL + 3, 3);
putint(total.t_dw, PROCSROW + 1, PROCSCOL + 6, 3);
putint(total.t_sl, PROCSROW + 1, PROCSCOL + 9, 3);
putint(total.t_sw, PROCSROW + 1, PROCSCOL + 12, 3);
PUTRATE(uvmexp.forks, VMSTATROW + 0, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.forks_ppwait, VMSTATROW + 1, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.forks_sharevm, VMSTATROW + 2, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.fltpgwait, VMSTATROW + 3, VMSTATCOL + 4, 5);
PUTRATE(uvmexp.fltrelck, VMSTATROW + 4, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.fltrelckok, VMSTATROW + 5, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.fltnoram, VMSTATROW + 6, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.fltamcopy, VMSTATROW + 7, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.flt_prcopy, VMSTATROW + 8, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.flt_przero, VMSTATROW + 9, VMSTATCOL + 3, 6);
PUTRATE(uvmexp.flt_acow, VMSTATROW + 10, VMSTATCOL, 9);
putint(s.uvmexp.freemin, VMSTATROW + 11, VMSTATCOL, 9);
putint(s.uvmexp.freetarg, VMSTATROW + 12, VMSTATCOL, 9);
putint(s.uvmexp.inactarg, VMSTATROW + 13, VMSTATCOL, 9);
putint(s.uvmexp.wired, VMSTATROW + 14, VMSTATCOL, 9);
PUTRATE(uvmexp.pdfreed, VMSTATROW + 15, VMSTATCOL, 9);
if (LINES - 1 > VMSTATROW + 16)
PUTRATE(uvmexp.pdscans, VMSTATROW + 16, VMSTATCOL, 9);
if (LINES - 1 > VMSTATROW + 17)
PUTRATE(uvmexp.zeropages, VMSTATROW + 17, VMSTATCOL, 9);
if (LINES - 1 > VMSTATROW + 18)
putint(s.uvmexp.kmapent, VMSTATROW + 18, VMSTATCOL, 9);
PUTRATE(uvmexp.pageins, PAGEROW + 2, PAGECOL + 5, 5);
PUTRATE(uvmexp.pdpageouts, PAGEROW + 2, PAGECOL + 10, 5);
PUTRATE(uvmexp.pgswapin, PAGEROW + 3, PAGECOL + 5, 5);
PUTRATE(uvmexp.pgswapout, PAGEROW + 3, PAGECOL + 10, 5);
PUTRATE(uvmexp.swtch, GENSTATROW + 1, GENSTATCOL, 6);
PUTRATE(uvmexp.traps, GENSTATROW + 1, GENSTATCOL + 6, 6);
PUTRATE(uvmexp.syscalls, GENSTATROW + 1, GENSTATCOL + 12, 6);
PUTRATE(uvmexp.intrs, GENSTATROW + 1, GENSTATCOL + 18, 6);
PUTRATE(uvmexp.softs, GENSTATROW + 1, GENSTATCOL + 24, 6);
PUTRATE(uvmexp.faults, GENSTATROW + 1, GENSTATCOL + 30, 5);
mvprintw(DISKROW, DISKCOL + 5, " ");
for (i = 0, c = 0; i < cur.dk_ndrive && c < DRIVESPACE; i++)
if (cur.dk_select[i] && (c + strlen(dr_name[i])) < DRIVESPACE) {
l = MAX(5, strlen(dr_name[i]));
mvprintw(DISKROW, DISKCOL + 5 + c,
" %*s", l, dr_name[i]);
c += 1 + l;
dinfo(i, c);
}
/* and pad the DRIVESPACE */
l = DRIVESPACE - c;
for (i = 0; i < 5; i++)
mvprintw(DISKROW + i, DISKCOL + 5 + c, "%*s", l, "");
putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 9);
putint(nchtotal.ncs_goodhits, NAMEIROW + 2, NAMEICOL + 10, 8);
#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 + 24, 7);
putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount),
NAMEIROW + 2, NAMEICOL + 33, 4, 0, 1);
putint(nchtotal.ncs_miss + nchtotal.ncs_long - nchtotal.ncs_pass2,
NAMEIROW + 2, NAMEICOL + 38, 7);
putfloat((nchtotal.ncs_miss + nchtotal.ncs_long - nchtotal.ncs_pass2) *
100.0 / nz(s.nchcount), NAMEIROW + 2, NAMEICOL + 45, 4, 0, 1);
#undef nz
}
