usr/src/usr.bin/systat/iostat.c

#ifndef lint
static char sccsid[] = "@(#)iostat.c	1.7 (Berkeley) %G%";
#endif

/*
 * iostat
 */
#include "systat.h"
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <nlist.h>

WINDOW *
openiostat()
{

	return (subwin(stdscr, LINES-1-5, 0, 5, 0));
}

closeiostat(w)
        WINDOW *w;
{

        if (w == NULL)
                return;
        wclear(w);
        wrefresh(w);
	delwin(w);
}

static struct nlist nlst[] = {
#define X_DK_BUSY       0
        { "_dk_busy" },
#define X_DK_TIME       1
        { "_dk_time" },
#define X_DK_XFER       2
        { "_dk_xfer" },
#define X_DK_WDS        3
        { "_dk_wds" },
#define X_DK_SEEK       4
        { "_dk_seek" },
#define X_CP_TIME       5
        { "_cp_time" },
#ifdef vax
#define X_MBDINIT       6
        { "_mbdinit" },
#define X_UBDINIT       7
        { "_ubdinit" },
#endif
        { "" },
};

static struct {
        int     dk_busy;
        long    cp_time[CPUSTATES];
        long    dk_time[DK_NDRIVE];
        long    dk_wds[DK_NDRIVE];
        long    dk_seek[DK_NDRIVE];
        long    dk_xfer[DK_NDRIVE];
} s, s1;

static  int linesperregion;
static  double etime;
static  int numbers = 0;                /* default display bar graphs */
static  int msps = 0;                   /* default ms/seek shown */
static  int dk_select[DK_NDRIVE];

initiostat()
{
        register  i;

        if (nlst[X_DK_BUSY].n_type == 0) {
                nlist("/vmunix", nlst);
                if (nlst[X_DK_BUSY].n_type == 0) {
                        error("Disk init information isn't in namelist");
                        return;
                }
        }
        if (ndrives == 0) {
                for (i = 0; i < DK_NDRIVE; i++)
                        if (dk_mspw[i] != 0.0)
                                sprintf(dr_name[i], "dk%d", i), ndrives++;
#ifdef vax
                read_names(nlst[X_MBDINIT].n_value, nlst[X_UBDINIT].n_value);
#endif
        }
        for (i = 0; i < DK_NDRIVE; i++)
                dk_select[i] = 1;
}

fetchiostat()
{

        if (nlst[X_DK_BUSY].n_type == 0)
                return;
        lseek(kmem, (long)nlst[X_DK_BUSY].n_value, L_SET);
        read(kmem, &s.dk_busy, sizeof s.dk_busy);
        lseek(kmem, (long)nlst[X_DK_TIME].n_value, L_SET);
        read(kmem, s.dk_time, sizeof s.dk_time);
        lseek(kmem, (long)nlst[X_DK_XFER].n_value, L_SET);
        read(kmem, s.dk_xfer, sizeof s.dk_xfer);
        lseek(kmem, (long)nlst[X_DK_WDS].n_value, L_SET);
        read(kmem, s.dk_wds, sizeof s.dk_wds);
        lseek(kmem, (long)nlst[X_DK_SEEK].n_value, L_SET);
        read(kmem, s.dk_seek, sizeof s.dk_seek);
        lseek(kmem, (long)nlst[X_CP_TIME].n_value, L_SET);
        read(kmem, s.cp_time, sizeof s.cp_time);
}

#define	INSET	10

labeliostat()
{
        int row;

        if (nlst[X_DK_BUSY].n_type == 0) {
                error("No dk_busy defined.");
                return;
        }
        row = 0;
        wmove(wnd, row, 0); wclrtobot(wnd);
        mvwaddstr(wnd, row++, INSET,
            "/0   /10  /20  /30  /40  /50  /60  /70  /80  /90  /100");
        mvwaddstr(wnd, row++, 0, "cpu  user|");
        mvwaddstr(wnd, row++, 0, "     nice|");
        mvwaddstr(wnd, row++, 0, "   system|");
        mvwaddstr(wnd, row++, 0, "     idle|");
        if (numbers)
                row = numlabels(row + 1);
        else
                row = barlabels(row + 1);
}

static
numlabels(row)
{
        int i, col, regions;

#define COLWIDTH        14
#define DRIVESPERLINE   ((wnd->_maxx - INSET) / COLWIDTH)
        regions = howmany(ndrives, DRIVESPERLINE);
        /*
         * Deduct -regions for blank line after each scrolling region.
         */
        linesperregion = (wnd->_maxy - row - regions) / regions;
        /*
         * Minimum region contains space for two
         * label lines and one line of statistics.
         */
        if (linesperregion < 3)
                linesperregion = 3;
        col = 0;
        for (i = 0; i < DK_NDRIVE; i++)
                if (dk_select[i] && dk_mspw[i] != 0.0) {
                        if (col + COLWIDTH >= wnd->_maxx - INSET) {
                                col = 0, row += linesperregion + 1;
                                if (row > wnd->_maxy - (linesperregion + 1))
                                        break;
                        }
                        mvwaddstr(wnd, row, col + 4, dr_name[i]);
                        mvwaddstr(wnd, row + 1, col, "bps tps msps");
                        col += COLWIDTH;
                }
        if (col)
                row += linesperregion + 1;
        return (row);
}

static
barlabels(row)
        int row;
{
        int i;

        mvwaddstr(wnd, row++, INSET,
            "/0   /5   /10  /15  /20  /25  /30  /35  /40  /45  /50");
        linesperregion = 2 + msps;
        for (i = 0; i < DK_NDRIVE; i++)
                if (dk_select[i] && dk_mspw[i] != 0.0) {
                        if (row > wnd->_maxy - linesperregion)
                                break;
                        mvwprintw(wnd, row++, 0, "%3.3s   bps|", dr_name[i]);
                        mvwaddstr(wnd, row++, 0, "      tps|");
                        if (msps)
                                mvwaddstr(wnd, row++, 0, "     msps|");
                }
        return (row);
}

showiostat()
{
        register int i, row, col;
        register long t;

        if (nlst[X_DK_BUSY].n_type == 0)
                return;
        for (i = 0; i < DK_NDRIVE; i++) {
#define X(fld)  t = s.fld[i]; s.fld[i] -= s1.fld[i]; s1.fld[i] = t
                X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time);
        }
        etime = 0;
        for(i = 0; i < CPUSTATES; i++) {
                X(cp_time);
                etime += s.cp_time[i];
        }
        if (etime == 0.0)
                etime = 1.0;
        etime /= (float) hz;
        row = 1;
        for (i = 0; i < CPUSTATES; i++)
                stat1(row++, i);
        if (!numbers) {
                row += 2;
                for (i = 0; i < DK_NDRIVE; i++)
                        if (dk_select[i] && dk_mspw[i] != 0.0) {
                                if (row > wnd->_maxy - linesperregion)
                                        break;
                                row = stats(row, INSET, i);
                        }
                return;
        }
        col = 0;
        wmove(wnd, row + linesperregion, 0);
        wdeleteln(wnd);
        wmove(wnd, row + 3, 0);
        winsertln(wnd);
        for (i = 0; i < DK_NDRIVE; i++)
                if (dk_select[i] && dk_mspw[i] != 0.0) {
                        if (col + COLWIDTH >= wnd->_maxx) {
                                col = 0, row += linesperregion + 1;
                                if (row > wnd->_maxy - (linesperregion + 1))
                                        break;
                                wmove(wnd, row + linesperregion, 0);
                                wdeleteln(wnd);
                                wmove(wnd, row + 3, 0);
                                winsertln(wnd);
                        }
                        (void) stats(row + 3, col, i);
                        col += COLWIDTH;
                }
}

static
stats(row, col, dn)
        int row, dn;
{
        register i;
        double atime, words, xtime, itime;

        atime = s.dk_time[dn];
        atime /= (float) hz;
        words = s.dk_wds[dn]*32.0;      /* number of words transferred */
        xtime = 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;
        if (numbers) {
                mvwprintw(wnd, row, col, "%3.0f%4.0f%5.1f",
                    words / 512 / etime, s.dk_xfer[dn] / etime,
                    s.dk_seek[dn] ? itime * 1000. / s.dk_seek[dn] : 0.0);
                return (row);
        }
        wmove(wnd, row++, col);
        histogram(words / 512 / etime, 50, 1.0);
        wmove(wnd, row++, col);
        histogram(s.dk_xfer[dn] / etime, 50, 1.0);
        if (msps) {
                wmove(wnd, row++, col);
                histogram(s.dk_seek[dn] ? itime * 1000. / s.dk_seek[dn] : 0,
                   50, 1.0);
        }
        return (row);
}

static
stat1(row, o)
        int row, o;
{
        register i;
        double time;

        time = 0;
        for (i = 0; i < CPUSTATES; i++)
                time += s.cp_time[i];
        if (time == 0.0)
                time = 1.0;
        wmove(wnd, row, INSET);
#define CPUSCALE        0.5
        histogram(100 * s.cp_time[o] / time, 50, CPUSCALE);
}

histogram(val, colwidth, scale)
        double val;
        int colwidth;
        double scale;
{
        char buf[10];
        register int k;
        register int v = (int)(val * scale) + 0.5;

        k = MIN(v, colwidth);
        if (v > colwidth) {
                sprintf(buf, "%4.1f", val);
                k -= strlen(buf);
                while (k--)
                        waddch(wnd, 'X');
                waddstr(wnd, buf);
                return;
        }
        while (k--)
                waddch(wnd, 'X');
        wclrtoeol(wnd);
}

cmdiostat(cmd, args)
        char *cmd, *args;
{
        int i;

        if (prefix(cmd, "msps")) {
                msps = !msps;
                goto fixdisplay;
        }
        if (prefix(cmd, "numbers")) {
                numbers = 1;
                goto fixdisplay;
        }
        if (prefix(cmd, "bars")) {
                numbers = 0;
                goto fixdisplay;
        }
        if (prefix(cmd, "display") || prefix(cmd, "add")) {
                dkselect(args, 1, dk_select);
                goto fixdisplay;
        }
        if (prefix(cmd, "ignore") || prefix(cmd, "delete")) {
                dkselect(args, 0, dk_select);
                goto fixdisplay;
        }
        if (prefix(cmd, "drives")) {
                move(CMDLINE, 0);
                for (i = 0; i < DK_NDRIVE; i++)
                        if (dk_mspw[i] != 0.0)
                                printw("%s ", dr_name[i]);
                return (1);
        }
        return (0);
fixdisplay:
        wclear(wnd);
        labeliostat();
        refresh();
        return (1);
}

prefix(s1, s2)
        register char *s1, *s2;
{

        while (*s1 == *s2) {
                if (*s1 == '\0')
                        return (1);
                s1++, s2++;
        }
        return (*s1 == '\0');
}
Commit	Line	Data
	1	#ifndef lint
	2	static char sccsid[] = "@(#)iostat.c 1.7 (Berkeley) %G%";
	3	#endif
	4
	5	/*
	6	* iostat
	7	*/
	8	#include "systat.h"
	9	#include <sys/param.h>
	10	#include <sys/buf.h>
	11	#include <sys/file.h>
	12	#include <nlist.h>
	13
	14	WINDOW *
	15	openiostat()
	16	{
	17
	18	return (subwin(stdscr, LINES-1-5, 0, 5, 0));
	19	}
	20
	21	closeiostat(w)
	22	WINDOW *w;
	23	{
	24
	25	if (w == NULL)
	26	return;
	27	wclear(w);
	28	wrefresh(w);
	29	delwin(w);
	30	}
	31
	32	static struct nlist nlst[] = {
	33	#define X_DK_BUSY 0
	34	{ "_dk_busy" },
	35	#define X_DK_TIME 1
	36	{ "_dk_time" },
	37	#define X_DK_XFER 2
	38	{ "_dk_xfer" },
	39	#define X_DK_WDS 3
	40	{ "_dk_wds" },
	41	#define X_DK_SEEK 4
	42	{ "_dk_seek" },
	43	#define X_CP_TIME 5
	44	{ "_cp_time" },
	45	#ifdef vax
	46	#define X_MBDINIT 6
	47	{ "_mbdinit" },
	48	#define X_UBDINIT 7
	49	{ "_ubdinit" },
	50	#endif
	51	{ "" },
	52	};
	53
	54	static struct {
	55	int dk_busy;
	56	long cp_time[CPUSTATES];
	57	long dk_time[DK_NDRIVE];
	58	long dk_wds[DK_NDRIVE];
	59	long dk_seek[DK_NDRIVE];
	60	long dk_xfer[DK_NDRIVE];
	61	} s, s1;
	62
	63	static int linesperregion;
	64	static double etime;
	65	static int numbers = 0; /* default display bar graphs */
	66	static int msps = 0; /* default ms/seek shown */
	67	static int dk_select[DK_NDRIVE];
	68
	69	initiostat()
	70	{
	71	register i;
	72
	73	if (nlst[X_DK_BUSY].n_type == 0) {
	74	nlist("/vmunix", nlst);
	75	if (nlst[X_DK_BUSY].n_type == 0) {
	76	error("Disk init information isn't in namelist");
	77	return;
	78	}
	79	}
	80	if (ndrives == 0) {
	81	for (i = 0; i < DK_NDRIVE; i++)
	82	if (dk_mspw[i] != 0.0)
	83	sprintf(dr_name[i], "dk%d", i), ndrives++;
	84	#ifdef vax
	85	read_names(nlst[X_MBDINIT].n_value, nlst[X_UBDINIT].n_value);
	86	#endif
	87	}
	88	for (i = 0; i < DK_NDRIVE; i++)
	89	dk_select[i] = 1;
	90	}
	91
	92	fetchiostat()
	93	{
	94
	95	if (nlst[X_DK_BUSY].n_type == 0)
	96	return;
	97	lseek(kmem, (long)nlst[X_DK_BUSY].n_value, L_SET);
	98	read(kmem, &s.dk_busy, sizeof s.dk_busy);
	99	lseek(kmem, (long)nlst[X_DK_TIME].n_value, L_SET);
	100	read(kmem, s.dk_time, sizeof s.dk_time);
	101	lseek(kmem, (long)nlst[X_DK_XFER].n_value, L_SET);
	102	read(kmem, s.dk_xfer, sizeof s.dk_xfer);
	103	lseek(kmem, (long)nlst[X_DK_WDS].n_value, L_SET);
	104	read(kmem, s.dk_wds, sizeof s.dk_wds);
	105	lseek(kmem, (long)nlst[X_DK_SEEK].n_value, L_SET);
	106	read(kmem, s.dk_seek, sizeof s.dk_seek);
	107	lseek(kmem, (long)nlst[X_CP_TIME].n_value, L_SET);
	108	read(kmem, s.cp_time, sizeof s.cp_time);
	109	}
	110
	111	#define INSET 10
	112
	113	labeliostat()
	114	{
	115	int row;
	116
	117	if (nlst[X_DK_BUSY].n_type == 0) {
	118	error("No dk_busy defined.");
	119	return;
	120	}
	121	row = 0;
	122	wmove(wnd, row, 0); wclrtobot(wnd);
	123	mvwaddstr(wnd, row++, INSET,
	124	"/0 /10 /20 /30 /40 /50 /60 /70 /80 /90 /100");
	125	mvwaddstr(wnd, row++, 0, "cpu user\|");
	126	mvwaddstr(wnd, row++, 0, " nice\|");
	127	mvwaddstr(wnd, row++, 0, " system\|");
	128	mvwaddstr(wnd, row++, 0, " idle\|");
	129	if (numbers)
	130	row = numlabels(row + 1);
	131	else
	132	row = barlabels(row + 1);
	133	}
	134
	135	static
	136	numlabels(row)
	137	{
	138	int i, col, regions;
	139
	140	#define COLWIDTH 14
	141	#define DRIVESPERLINE ((wnd->_maxx - INSET) / COLWIDTH)
	142	regions = howmany(ndrives, DRIVESPERLINE);
	143	/*
	144	* Deduct -regions for blank line after each scrolling region.
	145	*/
	146	linesperregion = (wnd->_maxy - row - regions) / regions;
	147	/*
	148	* Minimum region contains space for two
	149	* label lines and one line of statistics.
	150	*/
	151	if (linesperregion < 3)
	152	linesperregion = 3;
	153	col = 0;
	154	for (i = 0; i < DK_NDRIVE; i++)
	155	if (dk_select[i] && dk_mspw[i] != 0.0) {
	156	if (col + COLWIDTH >= wnd->_maxx - INSET) {
	157	col = 0, row += linesperregion + 1;
	158	if (row > wnd->_maxy - (linesperregion + 1))
	159	break;
	160	}
	161	mvwaddstr(wnd, row, col + 4, dr_name[i]);
	162	mvwaddstr(wnd, row + 1, col, "bps tps msps");
	163	col += COLWIDTH;
	164	}
	165	if (col)
	166	row += linesperregion + 1;
	167	return (row);
	168	}
	169
	170	static
	171	barlabels(row)
	172	int row;
	173	{
	174	int i;
	175
	176	mvwaddstr(wnd, row++, INSET,
	177	"/0 /5 /10 /15 /20 /25 /30 /35 /40 /45 /50");
	178	linesperregion = 2 + msps;
	179	for (i = 0; i < DK_NDRIVE; i++)
	180	if (dk_select[i] && dk_mspw[i] != 0.0) {
	181	if (row > wnd->_maxy - linesperregion)
	182	break;
	183	mvwprintw(wnd, row++, 0, "%3.3s bps\|", dr_name[i]);
	184	mvwaddstr(wnd, row++, 0, " tps\|");
	185	if (msps)
	186	mvwaddstr(wnd, row++, 0, " msps\|");
	187	}
	188	return (row);
	189	}
	190
	191	showiostat()
	192	{
	193	register int i, row, col;
	194	register long t;
	195
	196	if (nlst[X_DK_BUSY].n_type == 0)
	197	return;
	198	for (i = 0; i < DK_NDRIVE; i++) {
	199	#define X(fld) t = s.fld[i]; s.fld[i] -= s1.fld[i]; s1.fld[i] = t
	200	X(dk_xfer); X(dk_seek); X(dk_wds); X(dk_time);
	201	}
	202	etime = 0;
	203	for(i = 0; i < CPUSTATES; i++) {
	204	X(cp_time);
	205	etime += s.cp_time[i];
	206	}
	207	if (etime == 0.0)
	208	etime = 1.0;
	209	etime /= (float) hz;
	210	row = 1;
	211	for (i = 0; i < CPUSTATES; i++)
	212	stat1(row++, i);
	213	if (!numbers) {
	214	row += 2;
	215	for (i = 0; i < DK_NDRIVE; i++)
	216	if (dk_select[i] && dk_mspw[i] != 0.0) {
	217	if (row > wnd->_maxy - linesperregion)
	218	break;
	219	row = stats(row, INSET, i);
	220	}
	221	return;
	222	}
	223	col = 0;
	224	wmove(wnd, row + linesperregion, 0);
	225	wdeleteln(wnd);
	226	wmove(wnd, row + 3, 0);
	227	winsertln(wnd);
	228	for (i = 0; i < DK_NDRIVE; i++)
	229	if (dk_select[i] && dk_mspw[i] != 0.0) {
	230	if (col + COLWIDTH >= wnd->_maxx) {
	231	col = 0, row += linesperregion + 1;
	232	if (row > wnd->_maxy - (linesperregion + 1))
	233	break;
	234	wmove(wnd, row + linesperregion, 0);
	235	wdeleteln(wnd);
	236	wmove(wnd, row + 3, 0);
	237	winsertln(wnd);
	238	}
	239	(void) stats(row + 3, col, i);
	240	col += COLWIDTH;
	241	}
	242	}
	243
	244	static
	245	stats(row, col, dn)
	246	int row, dn;
	247	{
	248	register i;
	249	double atime, words, xtime, itime;
	250
	251	atime = s.dk_time[dn];
	252	atime /= (float) hz;
	253	words = s.dk_wds[dn]32.0; / number of words transferred */
	254	xtime = dk_mspw[dn]words; / transfer time */
	255	itime = atime - xtime; /* time not transferring */
	256	if (xtime < 0)
	257	itime += xtime, xtime = 0;
	258	if (itime < 0)
	259	xtime += itime, itime = 0;
	260	if (numbers) {
	261	mvwprintw(wnd, row, col, "%3.0f%4.0f%5.1f",
	262	words / 512 / etime, s.dk_xfer[dn] / etime,
	263	s.dk_seek[dn] ? itime * 1000. / s.dk_seek[dn] : 0.0);
	264	return (row);
	265	}
	266	wmove(wnd, row++, col);
	267	histogram(words / 512 / etime, 50, 1.0);
	268	wmove(wnd, row++, col);
	269	histogram(s.dk_xfer[dn] / etime, 50, 1.0);
	270	if (msps) {
	271	wmove(wnd, row++, col);
	272	histogram(s.dk_seek[dn] ? itime * 1000. / s.dk_seek[dn] : 0,
	273	50, 1.0);
	274	}
	275	return (row);
	276	}
	277
	278	static
	279	stat1(row, o)
	280	int row, o;
	281	{
	282	register i;
	283	double time;
	284
	285	time = 0;
	286	for (i = 0; i < CPUSTATES; i++)
	287	time += s.cp_time[i];
	288	if (time == 0.0)
	289	time = 1.0;
	290	wmove(wnd, row, INSET);
	291	#define CPUSCALE 0.5
	292	histogram(100 * s.cp_time[o] / time, 50, CPUSCALE);
	293	}
	294
	295	histogram(val, colwidth, scale)
	296	double val;
	297	int colwidth;
	298	double scale;
	299	{
	300	char buf[10];
	301	register int k;
	302	register int v = (int)(val * scale) + 0.5;
	303
	304	k = MIN(v, colwidth);
	305	if (v > colwidth) {
	306	sprintf(buf, "%4.1f", val);
	307	k -= strlen(buf);
	308	while (k--)
	309	waddch(wnd, 'X');
	310	waddstr(wnd, buf);
	311	return;
	312	}
	313	while (k--)
	314	waddch(wnd, 'X');
	315	wclrtoeol(wnd);
	316	}
	317
	318	cmdiostat(cmd, args)
	319	char cmd, args;
	320	{
	321	int i;
	322
	323	if (prefix(cmd, "msps")) {
	324	msps = !msps;
	325	goto fixdisplay;
	326	}
	327	if (prefix(cmd, "numbers")) {
	328	numbers = 1;
	329	goto fixdisplay;
	330	}
	331	if (prefix(cmd, "bars")) {
	332	numbers = 0;
	333	goto fixdisplay;
	334	}
	335	if (prefix(cmd, "display") \|\| prefix(cmd, "add")) {
	336	dkselect(args, 1, dk_select);
	337	goto fixdisplay;
	338	}
	339	if (prefix(cmd, "ignore") \|\| prefix(cmd, "delete")) {
	340	dkselect(args, 0, dk_select);
	341	goto fixdisplay;
	342	}
	343	if (prefix(cmd, "drives")) {
	344	move(CMDLINE, 0);
	345	for (i = 0; i < DK_NDRIVE; i++)
	346	if (dk_mspw[i] != 0.0)
	347	printw("%s ", dr_name[i]);
	348	return (1);
	349	}
	350	return (0);
	351	fixdisplay:
	352	wclear(wnd);
	353	labeliostat();
	354	refresh();
	355	return (1);
	356	}
	357
	358	prefix(s1, s2)
	359	register char s1, s2;
	360	{
	361
	362	while (s1 == s2) {
	363	if (*s1 == '\0')
	364	return (1);
	365	s1++, s2++;
	366	}
	367	return (*s1 == '\0');
	368	}