[unix-history] / usr / src / usr.bin / systat / swap.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

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

#include "systat.h"
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/text.h>
#include <sys/conf.h>
#include <sys/vmmac.h>
#include <machine/pte.h>

WINDOW *
openswap()
{

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

closeswap(w)
	WINDOW *w;
{

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

int	dmmin;
int	dmmax;
int	dmtext;
int	nswdev;
#define	MAXSWAPDEV	4
short	buckets[MAXSWAPDEV][NDMAP];
struct	swdevt *swdevt;
int	colwidth;

extern union {
        struct  user user;
        char    upages[UPAGES][NBPG];
} user;
#define u       user.user

showswap()
{
        register int i, j;
	register struct proc *pp;
	register struct text *xp;
	register int row;
	register int ts;
	register swblk_t *dp;

	if (xtext == 0)
		return;
	for (xp = xtext; xp < &xtext[ntext]; xp++) {
		if (xp->x_iptr == NULL)
			continue;
		ts = ctod(xp->x_size);
		dp = xp->x_daddr;
		for (i = 0; i < ts; i += dmtext) {
			j = ts - i;
			if (j > dmtext)
				j = dmtext;
#define	swatodev(addr)	(((addr) / dmmax) % nswdev)
			buckets[swatodev(*dp)][dmtoindex(j)]++;
			dp++;
		}
		if ((xp->x_flag & XPAGI) && xp->x_ptdaddr)
			buckets[swatodev(xp->x_ptdaddr)]
			    [dmtoindex(ctod(ctopt(xp->x_size)))]++;
	}
	row = swapdisplay(2, dmtext, 'X');
	if (kprocp == NULL)
		return;
        for (i = 0, pp = kprocp; i < nproc; i++, pp++) {
		if (pp->p_stat == 0 || pp->p_stat == SZOMB)
			continue;
		if (pp->p_flag & SSYS)
			continue;
		if (getu(pp) == 0)
			continue;
		vsacct(&u.u_dmap);
		vsacct(&u.u_smap);
#ifdef notdef
		if ((pp->p_flag & SLOAD) == 0)
			vusize(pp);
#endif
        }
	(void) swapdisplay(1+row, dmmax, 'X');
}

#define	OFFSET	5			/* left hand column */

swapdisplay(baserow, dmbound, c)
	int baserow, dmbound;
	char c;
{
	register int i, j, k, row;
	register short *pb;
	char buf[10];

	for (row = baserow, i = dmmin; i <= dmbound; i *= 2, row++) {
		for (j = 0; j < nswdev; j++) {
			pb = &buckets[j][row - baserow];
			wmove(wnd, row, OFFSET + j * (1 + colwidth));
			k = MIN(*pb, colwidth);
			if (*pb > colwidth) {
				sprintf(buf, " %d", *pb);
				k -= strlen(buf);
				while (k--)
					waddch(wnd, c);
				waddstr(wnd, buf);
			} else {
				while (k--)
					waddch(wnd, c);
				k = MAX(colwidth - *pb, 0);
				while (k--)
					waddch(wnd, ' ');
			}
			*pb = 0;
		}
	}
	return (row);
}

vsacct(dmp)
	register struct dmap *dmp;
{
	register swblk_t *ip;
	register int blk = dmmin, index = 0;

	for (ip = dmp->dm_map; dmp->dm_alloc > 0; ip++) {
		if (ip - dmp->dm_map >= NDMAP) {
			error("vsacct NDMAP");
			break;
		}
		if (*ip == 0)
			error("vsacct *ip == 0");
		buckets[swatodev(*ip)][index]++;
		dmp->dm_alloc -= blk;
		if (blk < dmmax) {
			blk *= 2;
			index++;
		}
	}
}

dmtoindex(dm)
	int dm;
{
	register int i, j;

	for (j = 0, i = dmmin; i <= dmmax; i *= 2, j++)
		if (dm <= i)
			return (j);
	error("dmtoindex(%d)", dm);
	return (NDMAP - 1);
}

static struct nlist nlst[] = {
#define X_PROC          0
        { "_proc" },
#define X_NPROC         1
        { "_nproc" },
#define X_USRPTMAP      2
        { "_Usrptmap" },
#define X_USRPT         3
        { "_usrpt" },
#define X_NSWAP         4
        { "_nswap" },
#define X_DMMIN         5
        { "_dmmin" },
#define X_DMMAX         6
        { "_dmmax" },
#define	X_DMTEXT	7
	{ "_dmtext" },
#define X_NSWDEV        8
        { "_nswdev" },
#define	X_SWDEVT	9
	{ "_swdevt" },
#define	X_NTEXT		10
	{ "_ntext" },
#define	X_TEXT		11
	{ "_text" },
        { "" }
};

initswap()
{

	if (nlst[X_PROC].n_type == 0) {
		nlist("/vmunix", nlst);
		if (nlst[X_PROC].n_type == 0) {
			error("namelist on /vmunix failed");
			return(0);
		}
	}
        if (nswdev == 0) {
                dmmin = getw(nlst[X_DMMIN].n_value);
                dmmax = getw(nlst[X_DMMAX].n_value);
                dmtext = getw(nlst[X_DMTEXT].n_value);
                nswdev = getw(nlst[X_NSWDEV].n_value);
		if (nswdev > MAXSWAPDEV)
			nswdev = MAXSWAPDEV;
		swdevt = (struct swdevt *)calloc(nswdev, sizeof (*swdevt));
		klseek(kmem, nlst[X_SWDEVT].n_value, L_SET);
		read(kmem, swdevt, nswdev * sizeof (struct swdevt));
		ntext = getw(nlst[X_NTEXT].n_value);
		textp = getw(nlst[X_TEXT].n_value);
        }
        if (procp == NULL) {
                procp = getw(nlst[X_PROC].n_value);
                nproc = getw(nlst[X_NPROC].n_value);
        }
	if (xtext == NULL)
		xtext = (struct text *)calloc(ntext, sizeof (struct text));
	if (kprocp == NULL)
                kprocp = (struct proc *)calloc(nproc, sizeof (struct proc));
        if (usrpt != NULL)
                return(1);
	usrpt = (struct pte *)nlst[X_USRPT].n_value;
	Usrptma = (struct pte *)nlst[X_USRPTMAP].n_value;
	if (pt == NULL)
		pt = (struct p_times *)malloc(nproc * sizeof (struct p_times));
	return(1);
}

fetchswap()
{

	if (nlst[X_PROC].n_type == 0)
		return;
	if (kprocp == NULL) {
                kprocp = (struct proc *)malloc(sizeof (*kprocp) * nproc);
		if (kprocp == NULL)
			return;
	}
        lseek(kmem, procp, L_SET);
        if (read(kmem, kprocp, sizeof (struct proc) * nproc) !=
	    sizeof (struct proc) * nproc) {
		error("couldn't read proc table");
		return;
	}
	if (xtext == NULL) {
		xtext = (struct text *)calloc(ntext, sizeof (struct text));
		if (xtext == NULL)
			return;
	}
	lseek(kmem, textp, L_SET);
	if (read(kmem, xtext, ntext * sizeof (struct text)) !=
	    sizeof (struct text) * ntext)
		error("couldn't read text table");
}

#ifdef vax
char	*devnames[] =
     { "hp", "ht", "up", "rk", "sw", "tm", "ts", "mt", "tu", "ra", "ut",
       "rb", "rx", "rl" };
#endif
#ifdef tahoe
char	*devnames[] = { "ud", "vd", "xp", "cy", "sw" };
#endif

labelswap()
{
	register int row;

	if (nswdev == 0) {
		error("Don't know how many swap devices.\n");
		return;
	}
	colwidth = (COLS - OFFSET - (nswdev - 1)) / nswdev;
	row = swaplabel(0, dmtext, 1);
	(void) swaplabel(row, dmmax, 0);
}

swaplabel(row, dmbound, donames)
	register int row;
	int dmbound, donames;
{
	register int i, j;

	for (i = 0; i < nswdev; i++) {
		if (donames)
			mvwprintw(wnd,
			    row, OFFSET + i*(1 + colwidth) + (colwidth - 3)/2,
			    "%s%d", devnames[major(swdevt[i].sw_dev)],
			        minor(swdevt[i].sw_dev) >> 3);
		for (j = 0; j + 5 < colwidth; j += 5)
			mvwprintw(wnd, row + donames,
			    OFFSET + i*(1 + colwidth) + j, "/%-2d  ", j);
	}
	row += 1 + donames;
	for (j = 0, i = dmmin; i <= dmbound; i *= 2, j++, row++) {
		int k;

		mvwprintw(wnd, row, 0, "%4d|", i);
		for (k = 1; k < nswdev; k++)
			mvwaddch(wnd, row, OFFSET + k*(1 + colwidth) - 1, '|');
	}
	return (row);
}
Commit	Line	Data
07ed1e09 KM	1	/*
	2	* Copyright (c) 1980 Regents of the University of California.
	3	* All rights reserved. The Berkeley software License Agreement
	4	* specifies the terms and conditions for redistribution.
	5	*/
	6
ce3b185b	7	#ifndef lint
03ceaa97	8	static char sccsid[] = "@(#)swap.c 5.4 (Berkeley) %G%";
07ed1e09	9	#endif not lint
ce3b185b SL	10
ce3b185b SL	11	#include "systat.h"
855ff304 KM	12	#include <sys/dir.h>
	13	#include <sys/user.h>
	14	#include <sys/proc.h>
	15	#include <sys/text.h>
	16	#include <sys/conf.h>
855ff304 KM	17	#include <sys/vmmac.h>
855ff304 KM	18	#include <machine/pte.h>
ce3b185b	19
d830bff6 SL	20	WINDOW *
d830bff6 SL	21	openswap()
ce3b185b SL	22	{
ce3b185b SL	23
b5eefd1e	24	return (subwin(stdscr, LINES-5-1, 0, 5, 0));
852c7064 SL	25	}
852c7064 SL	26
d830bff6 SL	27	closeswap(w)
d830bff6 SL	28	WINDOW *w;
852c7064 SL	29	{
852c7064 SL	30
d830bff6	31	if (w == NULL)
c6265927	32	return;
d830bff6 SL	33	wclear(w);
d830bff6 SL	34	wrefresh(w);
b5eefd1e	35	delwin(w);
ce3b185b SL	36	}
ce3b185b SL	37
d830bff6 SL	38	int dmmin;
	39	int dmmax;
	40	int dmtext;
	41	int nswdev;
	42	#define MAXSWAPDEV 4
	43	short buckets[MAXSWAPDEV][NDMAP];
	44	struct swdevt *swdevt;
e7a897ca SL	45	int colwidth;
e7a897ca SL	46
852c7064 SL	47	extern union {
	48	struct user user;
	49	char upages[UPAGES][NBPG];
	50	} user;
	51	#define u user.user
	52
ce3b185b SL	53	showswap()
ce3b185b SL	54	{
e7a897ca	55	register int i, j;
852c7064 SL	56	register struct proc *pp;
852c7064 SL	57	register struct text *xp;
ce3b185b	58	register int row;
852c7064 SL	59	register int ts;
852c7064 SL	60	register swblk_t *dp;
ce3b185b	61
c6265927	62	if (xtext == 0)
e7a897ca	63	return;
852c7064 SL	64	for (xp = xtext; xp < &xtext[ntext]; xp++) {
	65	if (xp->x_iptr == NULL)
	66	continue;
	67	ts = ctod(xp->x_size);
	68	dp = xp->x_daddr;
	69	for (i = 0; i < ts; i += dmtext) {
	70	j = ts - i;
	71	if (j > dmtext)
	72	j = dmtext;
	73	#define swatodev(addr) (((addr) / dmmax) % nswdev)
	74	buckets[swatodev(*dp)][dmtoindex(j)]++;
	75	dp++;
e7a897ca	76	}
852c7064 SL	77	if ((xp->x_flag & XPAGI) && xp->x_ptdaddr)
	78	buckets[swatodev(xp->x_ptdaddr)]
	79	[dmtoindex(ctod(ctopt(xp->x_size)))]++;
e7a897ca	80	}
b5eefd1e	81	row = swapdisplay(2, dmtext, 'X');
c6265927 SL	82	if (kprocp == NULL)
c6265927 SL	83	return;
852c7064 SL	84	for (i = 0, pp = kprocp; i < nproc; i++, pp++) {
	85	if (pp->p_stat == 0 \|\| pp->p_stat == SZOMB)
	86	continue;
	87	if (pp->p_flag & SSYS)
	88	continue;
c6265927	89	if (getu(pp) == 0)
852c7064	90	continue;
852c7064 SL	91	vsacct(&u.u_dmap);
852c7064 SL	92	vsacct(&u.u_smap);
ce3b185b	93	#ifdef notdef
852c7064 SL	94	if ((pp->p_flag & SLOAD) == 0)
852c7064 SL	95	vusize(pp);
ce3b185b	96	#endif
852c7064	97	}
b5eefd1e	98	(void) swapdisplay(1+row, dmmax, 'X');
e7a897ca	99	}
ce3b185b	100
b5eefd1e SL	101	#define OFFSET 5 /* left hand column */
b5eefd1e SL	102
852c7064 SL	103	swapdisplay(baserow, dmbound, c)
	104	int baserow, dmbound;
	105	char c;
ce3b185b	106	{
852c7064 SL	107	register int i, j, k, row;
	108	register short *pb;
	109	char buf[10];
ce3b185b	110
852c7064 SL	111	for (row = baserow, i = dmmin; i <= dmbound; i *= 2, row++) {
	112	for (j = 0; j < nswdev; j++) {
	113	pb = &buckets[j][row - baserow];
b5eefd1e	114	wmove(wnd, row, OFFSET + j * (1 + colwidth));
852c7064 SL	115	k = MIN(*pb, colwidth);
	116	if (*pb > colwidth) {
	117	sprintf(buf, " %d", *pb);
	118	k -= strlen(buf);
	119	while (k--)
	120	waddch(wnd, c);
	121	waddstr(wnd, buf);
	122	} else {
	123	while (k--)
	124	waddch(wnd, c);
	125	k = MAX(colwidth - *pb, 0);
	126	while (k--)
	127	waddch(wnd, ' ');
e7a897ca	128	}
852c7064	129	*pb = 0;
e7a897ca SL	130	}
e7a897ca SL	131	}
852c7064	132	return (row);
ce3b185b SL	133	}
ce3b185b SL	134
852c7064 SL	135	vsacct(dmp)
852c7064 SL	136	register struct dmap *dmp;
ce3b185b	137	{
852c7064 SL	138	register swblk_t *ip;
852c7064 SL	139	register int blk = dmmin, index = 0;
ce3b185b	140
852c7064 SL	141	for (ip = dmp->dm_map; dmp->dm_alloc > 0; ip++) {
	142	if (ip - dmp->dm_map >= NDMAP) {
	143	error("vsacct NDMAP");
	144	break;
	145	}
	146	if (*ip == 0)
	147	error("vsacct *ip == 0");
	148	buckets[swatodev(*ip)][index]++;
	149	dmp->dm_alloc -= blk;
	150	if (blk < dmmax) {
	151	blk *= 2;
	152	index++;
e7a897ca	153	}
e7a897ca	154	}
852c7064 SL	155	}
	156
	157	dmtoindex(dm)
	158	int dm;
	159	{
	160	register int i, j;
	161
	162	for (j = 0, i = dmmin; i <= dmmax; i *= 2, j++)
	163	if (dm <= i)
	164	return (j);
	165	error("dmtoindex(%d)", dm);
	166	return (NDMAP - 1);
ce3b185b	167	}
d830bff6 SL	168
	169	static struct nlist nlst[] = {
	170	#define X_PROC 0
	171	{ "_proc" },
	172	#define X_NPROC 1
	173	{ "_nproc" },
	174	#define X_USRPTMAP 2
	175	{ "_Usrptmap" },
	176	#define X_USRPT 3
	177	{ "_usrpt" },
	178	#define X_NSWAP 4
	179	{ "_nswap" },
	180	#define X_DMMIN 5
	181	{ "_dmmin" },
	182	#define X_DMMAX 6
	183	{ "_dmmax" },
	184	#define X_DMTEXT 7
	185	{ "_dmtext" },
	186	#define X_NSWDEV 8
	187	{ "_nswdev" },
	188	#define X_SWDEVT 9
	189	{ "_swdevt" },
	190	#define X_NTEXT 10
	191	{ "_ntext" },
	192	#define X_TEXT 11
	193	{ "_text" },
	194	{ "" }
	195	};
	196
	197	initswap()
	198	{
	199
	200	if (nlst[X_PROC].n_type == 0) {
	201	nlist("/vmunix", nlst);
	202	if (nlst[X_PROC].n_type == 0) {
	203	error("namelist on /vmunix failed");
c0b7e584	204	return(0);
d830bff6 SL	205	}
	206	}
	207	if (nswdev == 0) {
	208	dmmin = getw(nlst[X_DMMIN].n_value);
	209	dmmax = getw(nlst[X_DMMAX].n_value);
	210	dmtext = getw(nlst[X_DMTEXT].n_value);
	211	nswdev = getw(nlst[X_NSWDEV].n_value);
03ceaa97 SL	212	if (nswdev > MAXSWAPDEV)
03ceaa97 SL	213	nswdev = MAXSWAPDEV;
d830bff6 SL	214	swdevt = (struct swdevt )calloc(nswdev, sizeof (swdevt));
	215	klseek(kmem, nlst[X_SWDEVT].n_value, L_SET);
	216	read(kmem, swdevt, nswdev * sizeof (struct swdevt));
	217	ntext = getw(nlst[X_NTEXT].n_value);
	218	textp = getw(nlst[X_TEXT].n_value);
	219	}
	220	if (procp == NULL) {
	221	procp = getw(nlst[X_PROC].n_value);
	222	nproc = getw(nlst[X_NPROC].n_value);
	223	}
	224	if (xtext == NULL)
	225	xtext = (struct text *)calloc(ntext, sizeof (struct text));
	226	if (kprocp == NULL)
	227	kprocp = (struct proc *)calloc(nproc, sizeof (struct proc));
	228	if (usrpt != NULL)
c0b7e584	229	return(1);
d830bff6 SL	230	usrpt = (struct pte *)nlst[X_USRPT].n_value;
	231	Usrptma = (struct pte *)nlst[X_USRPTMAP].n_value;
	232	if (pt == NULL)
	233	pt = (struct p_times )malloc(nproc sizeof (struct p_times));
c0b7e584	234	return(1);
d830bff6 SL	235	}
	236
	237	fetchswap()
	238	{
	239
	240	if (nlst[X_PROC].n_type == 0)
	241	return;
	242	if (kprocp == NULL) {
	243	kprocp = (struct proc )malloc(sizeof (kprocp) * nproc);
	244	if (kprocp == NULL)
	245	return;
	246	}
	247	lseek(kmem, procp, L_SET);
	248	if (read(kmem, kprocp, sizeof (struct proc) * nproc) !=
	249	sizeof (struct proc) * nproc) {
	250	error("couldn't read proc table");
	251	return;
	252	}
	253	if (xtext == NULL) {
	254	xtext = (struct text *)calloc(ntext, sizeof (struct text));
	255	if (xtext == NULL)
	256	return;
	257	}
	258	lseek(kmem, textp, L_SET);
	259	if (read(kmem, xtext, ntext * sizeof (struct text)) !=
	260	sizeof (struct text) * ntext)
	261	error("couldn't read text table");
	262	}
	263
	264	#ifdef vax
	265	char *devnames[] =
	266	{ "hp", "ht", "up", "rk", "sw", "tm", "ts", "mt", "tu", "ra", "ut",
	267	"rb", "rx", "rl" };
	268	#endif
8d7d38c3 SL	269	#ifdef tahoe
	270	char *devnames[] = { "ud", "vd", "xp", "cy", "sw" };
	271	#endif
d830bff6 SL	272
	273	labelswap()
	274	{
d830bff6 SL	275	register int row;
	276
	277	if (nswdev == 0) {
	278	error("Don't know how many swap devices.\n");
	279	return;
	280	}
b5eefd1e SL	281	colwidth = (COLS - OFFSET - (nswdev - 1)) / nswdev;
b5eefd1e SL	282	row = swaplabel(0, dmtext, 1);
d830bff6 SL	283	(void) swaplabel(row, dmmax, 0);
	284	}
	285
	286	swaplabel(row, dmbound, donames)
	287	register int row;
	288	int dmbound, donames;
	289	{
	290	register int i, j;
	291
	292	for (i = 0; i < nswdev; i++) {
b5eefd1e SL	293	if (donames)
	294	mvwprintw(wnd,
	295	row, OFFSET + i*(1 + colwidth) + (colwidth - 3)/2,
	296	"%s%d", devnames[major(swdevt[i].sw_dev)],
	297	minor(swdevt[i].sw_dev) >> 3);
	298	for (j = 0; j + 5 < colwidth; j += 5)
	299	mvwprintw(wnd, row + donames,
	300	OFFSET + i*(1 + colwidth) + j, "/%-2d ", j);
d830bff6 SL	301	}
	302	row += 1 + donames;
	303	for (j = 0, i = dmmin; i <= dmbound; i *= 2, j++, row++) {
	304	int k;
	305
b5eefd1e	306	mvwprintw(wnd, row, 0, "%4d\|", i);
d830bff6	307	for (k = 1; k < nswdev; k++)
b5eefd1e	308	mvwaddch(wnd, row, OFFSET + k*(1 + colwidth) - 1, '\|');
d830bff6 SL	309	}
	310	return (row);
	311	}