[unix-history] / .ref-5cb41021d721f4e0ac572d592613f963e495d1ff / usr / src / old / sdb / ps.c

/*
 * ps; VAX 4BSD version
 */

#include <stdio.h>
#include <ctype.h>
#include <olda.out.h>
#include <pwd.h>
#include <sys/param.h>
#include <sys/tty.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/pte.h>
#include <sys/vm.h>
#include <sys/text.h>
#include <sys/stat.h>

struct nlist nl[] = {
	{ "_proc" },
#define	X_PROC		0
	{ "_Usrptma" },
#define	X_USRPTMA	1
	{ "_usrpt" },
#define	X_USRPT		2
	{ "_text" },
#define	X_TEXT		3
	{ "_nswap" },
#define	X_NSWAP		4
	{ 0 },
};

struct	savcom {
	union {
		struct	lsav *lp;
		float	u_pctcpu;
		struct	vsav *vp;
		int	s_ssiz;
	} sun;
	struct	asav *ap;
} savcom[NPROC];

struct	asav {
	char	*a_cmdp;
	int	a_flag;
	short	a_stat, a_uid, a_pid, a_nice;
	size_t	a_size, a_rss;
	char	a_tty[4];
	dev_t	a_ttyd;
	time_t	a_time;
};

char	*lhdr;
/*	    F S UID   PID  PPID CP PRI NICE ADDR  SZ  RSS WCHAN TTY TIME */
struct	lsav {
	short	l_ppid;
	char	l_cpu, l_pri;
	int	l_addr;
	caddr_t	l_wchan;
};

char	*uhdr;
/*	 USER       PID %%CPU NICE  SZ  RSS TTY TIME */

char	*shdr;
/*	 SSIZ   PID TTY TIME */

char	*vhdr;
/*	F     PID TT   TIME TIM SL  MINFLT  MAJFLT SIZE  RSS  SRS TSIZ TRS PF*/
struct	vsav {
	short	v_slptime, v_pri;
	u_int	v_minflt, v_majflt;
	size_t	v_swrss, v_tsiz, v_txtrss, v_txtswrss;
	short	v_xccount;
	short	v_aveflt;
};

struct	proc mproc;
struct	text *text;

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

#define clear(x) 	((int)x & 0x7fffffff)

int	chkpid;
int	aflg, cflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;
char	*tptr;
char	*gettty(), *getcmd(), *getname(), *savestr(), *alloc();
int	pscomp();
int	nswap;
struct	pte *Usrptma, *usrpt;

int	ndev;
struct devl {
	char	dname[DIRSIZ];
	dev_t	dev;
	struct	devl *next;
	struct	devl *cand;
} devl[256], *cand[16], *cons;

struct	savcom savcom[NPROC];
int	npr;

int	cmdstart;
int	twidth;
char	*kmemf, *memf, *swapf, *nlistf;
int	kmem, mem, swap;

int	pcbpf;
int	argaddr;
extern	char _sobuf[];

main(argc, argv)
	char **argv;
{
	register int i;
	register char *ap;
	int uid;
	off_t procp;

	setbuf(stdout, _sobuf);
	argc--, argv++;
	if (argc > 0) {
		ap = argv[0];
		while (*ap) switch (*ap++) {

		case 'a':
			aflg++;
			break;
		case 'c':
			cflg = !cflg;
			break;
		case 'g':
			gflg++;
			break;
		case 'k':
			kflg++;
			break;
		case 'l':
			lflg++;
			break;
		case 's':
			sflg++;
			break;
		case 't':
			if (*ap)
				tptr = ap;
			aflg++;
			gflg++;
			if (*tptr == '?')
				xflg++;
			while (*ap)
				ap++;
			break;
		case 'u':
			uflg++;
			break;
		case 'v':
			cflg = 1;
			vflg++;
			break;
		case 'w':
			if (twidth == 80)
				twidth = 132;
			else
				twidth = BUFSIZ;
			break;
		case 'x':
			xflg++;
			break;
		default:
			if (!isdigit(ap[-1]))
				break;
			chkpid = atoi(--ap);
			*ap = 0;
			aflg++;
			xflg++;
			break;
		}
	}
	openfiles(argc, argv);
	getkvars(argc, argv);
	getdev();
	uid = getuid();
	printhdr();
	procp = nl[X_PROC].n_value;
	for (i=0; i<NPROC; i++) {
		lseek(kmem, (char *)procp, 0);
		if (read(kmem, (char *)&mproc, sizeof mproc) != sizeof mproc)
			cantread("proc table", kmemf);
		procp += sizeof (mproc);
		if (mproc.p_stat == 0 || mproc.p_pgrp == 0 && xflg == 0)
			continue;
		if (tptr == 0 && gflg == 0 && xflg == 0 &&
		    mproc.p_ppid == 1 && (mproc.p_flag&SDETACH) == 0)
			continue;
		if (uid != mproc.p_uid && aflg==0 ||
		    chkpid != 0 && chkpid != mproc.p_pid)
			continue;
		if (vflg && gflg == 0 && xflg == 0) {
			if (mproc.p_stat == SZOMB)
				continue;
			if (mproc.p_slptime > MAXSLP &&
			    (mproc.p_stat == SSLEEP || mproc.p_stat == SSTOP))
				continue;
		}
		save();
	}
	qsort(savcom, npr, sizeof(savcom[0]), pscomp);
	for (i=0; i<npr; i++) {
		register struct savcom *sp = &savcom[i];
		if (lflg)
			lpr(sp);
		else if (vflg)
			vpr(sp);
		else if (uflg)
			upr(sp);
		else
			spr(sp);
		if (sp->ap->a_pid == 0)
			printf(" swapper");
		else if (sp->ap->a_pid == 2)
			printf(" pagedaemon");
		else
			printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
		printf("\n");
	}
	exit(npr == 0);
}

openfiles(argc, argv)
	char **argv;
{

	kmemf = "/dev/kmem";
	if (kflg)
		kmemf = argc > 1 ? argv[1] : "/vmcore";
	kmem = open(kmemf, 0);
	if (kmem < 0) {
		perror(kmemf);
		exit(1);
	}
	if (kflg)  {
		mem = kmem;
		memf = kmemf;
	} else {
		memf = "/dev/mem";
		mem = open(memf, 0);
		if (mem < 0) {
			perror(memf);
			exit(1);
		}
	}
	swapf = argc>2 ? argv[2]: "/dev/drum";
	swap = open(swapf, 0);
	if (swap < 0) {
		perror(swapf);
		exit(1);
	}
}

getkvars(argc, argv)
	char **argv;
{
	register struct nlist *nlp;

	nlistf = argc > 3 ? argv[3] : "/vmunix";
	nlist(nlistf, nl);
	if (nl[0].n_type == 0) {
		fprintf(stderr, "%s: No namelist\n", nlistf);
		exit(1);
	}
	if (chdir("/dev") < 0) {
		perror("/dev");
		exit(1);
	}
	if (kflg)
		for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
			nlp->n_value = clear(nlp->n_value);
	Usrptma = (struct pte *)nl[X_USRPTMA].n_value;
	usrpt = (struct pte *)nl[X_USRPT].n_value;
	lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
	if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
/*###287 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(287)%%%*/
		cantread("nswap", kmemf);
/*###288 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(288)%%%*/
/*###288 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(288)%%%*/
		exit(1);
	}
	if (vflg) {
		text = (struct text *)alloc(NTEXT * sizeof (struct text));
		if (text == 0) {
			fprintf(stderr, "no room for text table\n");
			exit(1);
		}
		lseek(kmem, (long)nl[X_TEXT].n_value, 0);
		if (read(kmem, text, sizeof (text)) != sizeof (text)) {
/*###298 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(298)%%%*/
			cantread("text table", kmemf);
/*###299 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(299)%%%*/
/*###299 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(299)%%%*/
			exit(1);
		}
	}
}

printhdr()
{
	char *hdr;

	if (sflg+lflg+vflg+uflg > 1) {
		fprintf(stderr, "ps: specify only one of s,l,v and u\n");
		exit(1);
	}
	hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr));
	if (lflg+vflg+uflg+sflg == 0)
		hdr += strlen(" SSIZ");
	cmdstart = strlen(hdr);
	printf("%s COMMAND\n", hdr);
	fflush(stdout);
}

cantread(what, fromwhat)
	char *what, *fromwhat;
{

	fprintf(stderr, "ps: error reading %s from %s", what, fromwhat);
}

getdev()
{
	register FILE *df;
	struct stat sbuf;
	struct direct dbuf;

	if ((df = fopen("/dev", "r")) == NULL) {
		fprintf(stderr, "Can't open /dev\n");
		exit(1);
	}
	ndev = 0;
	while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
		if (dbuf.d_ino == 0)
			continue;
		if (stat(dbuf.d_name, &sbuf) < 0)
			continue;
		if ((sbuf.st_mode&S_IFMT) != S_IFCHR)
			continue;
		strcpy(devl[ndev].dname, dbuf.d_name);
		devl[ndev].dev = sbuf.st_rdev;
		ndev++;
	}
	fclose(df);
}

save()
{
	register struct savcom *sp;
	register struct asav *ap;
	register char *cp;
	char *ttyp, *cmdp;

	if (mproc.p_stat != SZOMB && getu() == 0)
		return;
	ttyp = gettty();
	if (tptr && strcmpn(tptr, ttyp, 2))
		return;
	sp = &savcom[npr];
	cmdp = getcmd();
	if (cmdp == 0)
		return;
	sp->ap = ap = (struct asav *)alloc(sizeof (struct asav));
	sp->ap->a_cmdp = cmdp;
#define e(a,b) ap->a = mproc.b
	e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice);
	e(a_uid, p_uid); e(a_pid, p_pid); e(a_rss, p_rssize);
#undef e
	ap->a_size = mproc.p_dsize + mproc.p_ssize;
	ap->a_tty[0] = ttyp[0];
	ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' ';
	ap->a_ttyd = u.u_ttyd;
	ap->a_time = u.u_vm.vm_utime + u.u_vm.vm_stime;
	if (lflg) {
		register struct lsav *lp;

		sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav));
#define e(a,b) lp->a = mproc.b
		e(l_ppid, p_ppid); e(l_cpu, p_cpu);
		e(l_pri, p_pri); e(l_wchan, p_wchan);
#undef e
		lp->l_addr = pcbpf;
	} else if (vflg) {
		register struct vsav *vp;
		register struct text *xp;

		sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav));
#define e(a,b) vp->a = mproc.b
		e(v_slptime, p_slptime); e(v_pri, p_pri);
		e(v_swrss, p_swrss); e(v_aveflt, p_aveflt);
#undef e
		vp->v_minflt = u.u_vm.vm_minflt;
		vp->v_majflt = u.u_vm.vm_majflt;
		if (mproc.p_textp) {
			xp = &text[mproc.p_textp -
			    (struct text *)nl[X_TEXT].n_value];
			vp->v_tsiz = xp->x_size;
			vp->v_txtrss = xp->x_rssize;
			vp->v_txtswrss = xp->x_swrss;
			vp->v_xccount = xp->x_ccount;
		} else {
			vp->v_tsiz = 0;
			vp->v_txtrss = 0;
			vp->v_xccount = 0;
			vp->v_txtswrss = 0;
		}
	} else if (uflg)
		sp->sun.u_pctcpu = 0.0;
	else if (sflg) {
		for (cp = (char *)u.u_stack;
		    cp < (char *)&u + ctob(UPAGES); )
			if (*cp++)
				break;
		sp->sun.s_ssiz = (int) ((char *)&u + ctob(UPAGES) - cp);
	}
	npr++;
}

getu()
{
	struct pte *pteaddr, apte, arguutl[UPAGES+CLSIZE];
	register int i;
	int ncl, size;

	size = sflg ? ctob(UPAGES) : sizeof (struct user);
	if ((mproc.p_flag & SLOAD) == 0) {
		lseek(swap, ctob(mproc.p_swaddr), 0);
		if (read(swap, (char *)&u, size) != size) {
			fprintf(stderr, "ps: cant read u for pid %d from %s\n",
			    mproc.p_pid, swapf);
			return (0);
		}
		pcbpf = 0;
		argaddr = 0;
		return (1);
	}
	pteaddr = &Usrptma[btokmx(mproc.p_p0br) + mproc.p_szpt - 1];
	lseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0);
	if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
		printf("ps: cant read indir pte to get u for pid %d from %s\n",
		    mproc.p_pid, swapf);
		return (0);
	}
	lseek(mem,
	    ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
	if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
		printf("ps: cant read page table for u of pid %d from %s\n",
		    mproc.p_pid, swapf);
		return (0);
	}
	if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
		argaddr = ctob(arguutl[0].pg_pfnum);
	else
		argaddr = 0;
	pcbpf = arguutl[CLSIZE].pg_pfnum;
	ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
	while (--ncl >= 0) {
		i = ncl * CLSIZE;
		lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
		if (read(mem, user.upages[CLSIZE+i], CLSIZE*NBPG)
		   != CLSIZE*NBPG) {
			printf("ps: cant read page %d of u of pid %d from %s\n",
			    arguutl[CLSIZE+i].pg_pfnum, mproc.p_pid, memf);
			return(0);
		}
	}
	return (1);
}

char *
getcmd()
{
	char cmdbuf[BUFSIZ];
	union {
		char	argc[CLSIZE*NBPG];
		int	argi[CLSIZE*NBPG/sizeof (int)];
	} argspac;
	register char *cp;
	register int *ip;
	char c;
	int nbad;
	struct dblock db;

	if (mproc.p_stat == SZOMB)
		return ("");
	if (cflg)
		goto retucomm;
	if ((mproc.p_flag & SLOAD) == 0 || argaddr == 0) {
		vstodb(0, CLSIZE, &u.u_smap, &db, 1);
		lseek(swap, ctob(db.db_base), 0);
		if (read(swap, (char *)&argspac, sizeof(argspac))
		    != sizeof(argspac))
			goto bad;
	} else {
		lseek(mem, argaddr, 0);
		if (read(mem, (char *)&argspac, sizeof (argspac))
		    != sizeof (argspac))
			goto bad;
	}
	ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
	*--ip = 0;
	while (*--ip)
		if (ip == argspac.argi)
			goto retucomm;
	*(char *)ip = ' ';
	ip++;
	nbad = 0;
	for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) {
		c = *cp & 0177;
		if (c == 0)
			*cp = ' ';
		else if (c < ' ' || c > 0176) {
			if (++nbad >= 5) {
				*cp++ = ' ';
				break;
			}
			*cp = '?';
		} else if (c == '=') {
			while (*--cp != ' ')
				if (cp <= (char *)ip)
					break;
			break;
		}
	}
	*cp = 0;
	while (*--cp == ' ')
		*cp = 0;
	cp = (char *)ip;
	strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
	if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') {
		strcat(cp, " (");
		strncat(cp, u.u_comm, sizeof(u.u_comm));
		strcat(cp, ")");
	}
	if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-')
		return (0);
	return (savestr(cmdbuf));

bad:
	fprintf(stderr, "ps: error locating command name for pid %d\n",
	    mproc.p_pid);
retucomm:
	strcat(cp, " (");
	strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm));
	strcat(cp, ")");
	return (savestr(cmdbuf));
}

char	*lhdr =
"    F S UID   PID  PPID CP PRI NICE ADDR  SZ  RSS WCHAN TTY TIME";
lpr(sp)
	struct savcom *sp;
{
	register struct asav *ap = sp->ap;
	register struct lsav *lp = sp->sun.lp;

	printf("%5x %c %4d%5u%6u%3d%4d%4d%6x%4d%5d",
	    ap->a_flag, "0SWRIZT"[ap->a_stat], ap->a_uid,
	    ap->a_pid, lp->l_ppid, lp->l_cpu&0377, lp->l_pri-PZERO,
	    ap->a_nice-NZERO, lp->l_addr, ap->a_size, ap->a_rss);
	printf(lp->l_wchan ? "%6x" : "      ", lp->l_wchan);
	ptty(ap->a_tty);
	ptime(ap);
}

ptty(tp)
	char *tp;
{

	printf(" %-2.2s", tp);
}

ptime(ap)
	struct asav *ap;
{

	if (ap->a_stat == SZOMB)
		printf("  <defunct>");
	else
		printf("%3ld:%02ld", ap->a_time / HZ, ap->a_time % HZ);
}

char	*uhdr =
"USER       PID %%CPU NICE  SZ  RSS TTY TIME";
upr(sp)
	struct savcom *sp;
{
	register struct asav *ap = sp->ap;

	printf("%-8.8s%5u%5.1f%4d%4d%5d",
	    getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, ap->a_nice,
	    ap->a_size, ap->a_rss);
	ptty(ap->a_tty);
	ptime(ap);
}

char *vhdr =
"F     PID TT   TIME TIM SL  MINFLT  MAJFLT SIZE  RSS  SRS TSIZ TRS PF";
vpr(sp)
	struct savcom *sp;
{
	register struct vsav *vp = sp->sun.vp;
	register struct asav *ap = sp->ap;
	char stat, nice, anom;

	switch (ap->a_stat) {

	case SSLEEP:
	case SSTOP:
		if ((ap->a_flag & SLOAD) == 0)
			stat = 'W';
		else if (vp->v_pri >= PZERO)
			stat = 'S';
		else if (ap->a_flag & SPAGE)
			stat = 'P';
		else
			stat = 'D';
		break;

	case SRUN:
	case SIDL:
		stat = ap->a_flag & SLOAD ? 'R' : 'W';
		break;
	}
	nice = ap->a_nice > NZERO ? 'N' : ' ';
	anom = ap->a_flag & (SANOM|SUANOM) ? 'A' : ' ';
	printf("%c%c%c%5u", stat, nice, anom, ap->a_pid);
	ptty(ap->a_tty);
	ptime(ap);
	printf("%3d%3d%8d%8d%5d%5d%5d%5d%4d%3d",
	   ap->a_time, vp->v_slptime, vp->v_majflt, vp->v_minflt,
	   ap->a_size, ap->a_rss, vp->v_swrss, vp->v_tsiz, vp->v_txtrss,
	   vp->v_aveflt);
}

char	*shdr =
" SSIZ   PID TTY TIME";
spr(sp)
	struct savcom *sp;
{
	register struct asav *ap = sp->ap;

	if (sflg)
		printf("%5d", sp->sun.s_ssiz);
	printf(" %5u", ap->a_pid);
	ptty(ap->a_tty);
	ptime(ap);
}

char *
gettty()
{
	register i;
	register char *p;

	if (u.u_ttyp == 0)
		return("?");
	for (i=0; i<ndev; i++) {
		if (devl[i].dev == u.u_ttyd) {
			p = devl[i].dname;
			if (p[0]=='t' && p[1]=='t' && p[2]=='y')
				p += 3;
			return(p);
		}
	}
	return("?");
}

/*
 * Given a base/size pair in virtual swap area,
 * return a physical base/size pair which is the
 * (largest) initial, physically contiguous block.
 */
vstodb(vsbase, vssize, dmp, dbp, rev)
	register int vsbase;
	int vssize;
	struct dmap *dmp;
	register struct dblock *dbp;
{
	register int blk = DMMIN;
	register swblk_t *ip = dmp->dm_map;

	if (vsbase < 0 || vsbase + vssize > dmp->dm_size)
		panic("vstodb");
	while (vsbase >= blk) {
		vsbase -= blk;
		if (blk < DMMAX)
			blk *= 2;
		ip++;
	}
	if (*ip <= 0 || *ip + blk > nswap)
		panic("vstodb *ip");
	dbp->db_size = min(vssize, blk - vsbase);
	dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
}

/*ARGSUSED*/
panic(cp)
	char *cp;
{

#ifdef DEBUG
	printf("%s\n", cp);
#endif
}

min(a, b)
{

	return (a < b ? a : b);
}

pscomp(s1, s2)
	struct savcom *s1, *s2;
{
	register int i;

	if (vflg)
		return (vsize(s2) - vsize(s1));
	i = s1->ap->a_ttyd - s2->ap->a_ttyd;
	if (i == 0)
		i = s1->ap->a_pid - s2->ap->a_pid;
	return (i);
}

vsize(sp)
	struct savcom *sp;
{
	register struct asav *ap = sp->ap;
	register struct vsav *vp = sp->sun.vp;
	
	if (ap->a_flag & SLOAD)
		return (ap->a_rss +
		    vp->v_txtrss / (vp->v_xccount ? vp->v_xccount : 1));
	return (vp->v_swrss + (vp->v_xccount ? 0 : vp->v_txtswrss));
}

#define	NMAX	8
#define	NUID	2048

char	names[NUID][NMAX+1];

/*
 * Stolen from ls...
 */
char *
getname(uid)
{
	register struct passwd *pw;
	static init;
	struct passwd *getpwent();

	if (names[uid][0])
		return (&names[uid][0]);
	if (init == 2)
		return (0);
	if (init == 0)
		setpwent(), init = 1;
	while (pw = getpwent()) {
		if (pw->pw_uid >= NUID)
			continue;
		if (names[pw->pw_uid][0])
			continue;
		strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
		if (pw->pw_uid == uid)
			return (&names[uid][0]);
	}
	init = 2;
	endpwent();
	return (0);
}

char	*freebase;
int	nleft;

char *
alloc(size)
	int size;
{
	register char *cp;
	register int i;

	if (size > nleft) {
		freebase = (char *)sbrk(size > 2048 ? size : 2048);
		if (freebase == 0) {
			fprintf(stderr, "ps: ran out of memory\n");
			exit(1);
		}
	}
	cp = freebase;
	for (i = size; --i >= 0; )
		*cp++ = 0;
	freebase = cp;
	return (cp - size);
}

char *
savestr(cp)
	char *cp;
{
	register int len;
	register char *dp;

	len = strlen(cp);
	dp = (char *)alloc(len+1);
	strcpy(dp, cp);
	return (dp);
}
Commit	Line	Data
87b3cf93 BJ	1	/*
	2	* ps; VAX 4BSD version
	3	*/
	4
	5	#include <stdio.h>
	6	#include <ctype.h>
	7	#include <olda.out.h>
	8	#include <pwd.h>
	9	#include <sys/param.h>
	10	#include <sys/tty.h>
	11	#include <sys/dir.h>
	12	#include <sys/user.h>
	13	#include <sys/proc.h>
	14	#include <sys/pte.h>
	15	#include <sys/vm.h>
	16	#include <sys/text.h>
	17	#include <sys/stat.h>
	18
	19	struct nlist nl[] = {
	20	{ "_proc" },
	21	#define X_PROC 0
	22	{ "_Usrptma" },
	23	#define X_USRPTMA 1
	24	{ "_usrpt" },
	25	#define X_USRPT 2
	26	{ "_text" },
	27	#define X_TEXT 3
	28	{ "_nswap" },
	29	#define X_NSWAP 4
	30	{ 0 },
	31	};
	32
	33	struct savcom {
	34	union {
	35	struct lsav *lp;
	36	float u_pctcpu;
	37	struct vsav *vp;
	38	int s_ssiz;
	39	} sun;
	40	struct asav *ap;
	41	} savcom[NPROC];
	42
	43	struct asav {
	44	char *a_cmdp;
	45	int a_flag;
	46	short a_stat, a_uid, a_pid, a_nice;
	47	size_t a_size, a_rss;
	48	char a_tty[4];
	49	dev_t a_ttyd;
	50	time_t a_time;
	51	};
	52
	53	char *lhdr;
	54	/* F S UID PID PPID CP PRI NICE ADDR SZ RSS WCHAN TTY TIME */
	55	struct lsav {
	56	short l_ppid;
	57	char l_cpu, l_pri;
	58	int l_addr;
	59	caddr_t l_wchan;
	60	};
	61
	62	char *uhdr;
	63	/* USER PID %%CPU NICE SZ RSS TTY TIME */
	64
65	char *shdr;
66	/* SSIZ PID TTY TIME */
67
68	char *vhdr;
69	/* F PID TT TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF*/
70	struct vsav {
71	short v_slptime, v_pri;
72	u_int v_minflt, v_majflt;
73	size_t v_swrss, v_tsiz, v_txtrss, v_txtswrss;
74	short v_xccount;
75	short v_aveflt;
76	};
77
78	struct proc mproc;
79	struct text *text;
80
81	union {
82	struct user user;
83	char upages[UPAGES][NBPG];
84	} user;
85	#define u user.user
86
87	#define clear(x) ((int)x & 0x7fffffff)
88
89	int chkpid;
90	int aflg, cflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;
91	char *tptr;
92	char gettty(), getcmd(), getname(), savestr(), *alloc();
93	int pscomp();
94	int nswap;
95	struct pte Usrptma, usrpt;
96
97	int ndev;
98	struct devl {
99	char dname[DIRSIZ];
100	dev_t dev;
101	struct devl *next;
102	struct devl *cand;
103	} devl[256], cand[16], cons;
104
105	struct savcom savcom[NPROC];
106	int npr;
107
108	int cmdstart;
109	int twidth;
110	char kmemf, memf, swapf, nlistf;
111	int kmem, mem, swap;
112
113	int pcbpf;
114	int argaddr;
115	extern char _sobuf[];
116
117	main(argc, argv)
118	char **argv;
119	{
120	register int i;
121	register char *ap;
122	int uid;
123	off_t procp;
124
125	setbuf(stdout, _sobuf);
126	argc--, argv++;
127	if (argc > 0) {
128	ap = argv[0];
129	while (ap) switch (ap++) {
130
131	case 'a':
132	aflg++;
133	break;
134	case 'c':
135	cflg = !cflg;
136	break;
137	case 'g':
138	gflg++;
139	break;
140	case 'k':
141	kflg++;
142	break;
143	case 'l':
144	lflg++;
145	break;
146	case 's':
147	sflg++;
148	break;
149	case 't':
150	if (*ap)
151	tptr = ap;
152	aflg++;
153	gflg++;
154	if (*tptr == '?')
155	xflg++;
156	while (*ap)
157	ap++;
158	break;
159	case 'u':
160	uflg++;
161	break;
162	case 'v':
163	cflg = 1;
164	vflg++;
165	break;
166	case 'w':
167	if (twidth == 80)
168	twidth = 132;
169	else
170	twidth = BUFSIZ;
171	break;
172	case 'x':
173	xflg++;
174	break;
175	default:
176	if (!isdigit(ap[-1]))
177	break;
178	chkpid = atoi(--ap);
179	*ap = 0;
180	aflg++;
181	xflg++;
182	break;
183	}
184	}
185	openfiles(argc, argv);
186	getkvars(argc, argv);
187	getdev();
188	uid = getuid();
189	printhdr();
190	procp = nl[X_PROC].n_value;
191	for (i=0; i<NPROC; i++) {
192	lseek(kmem, (char *)procp, 0);
193	if (read(kmem, (char *)&mproc, sizeof mproc) != sizeof mproc)
194	cantread("proc table", kmemf);
195	procp += sizeof (mproc);
196	if (mproc.p_stat == 0 \|\| mproc.p_pgrp == 0 && xflg == 0)
197	continue;
198	if (tptr == 0 && gflg == 0 && xflg == 0 &&
199	mproc.p_ppid == 1 && (mproc.p_flag&SDETACH) == 0)
200	continue;
201	if (uid != mproc.p_uid && aflg==0 \|\|
202	chkpid != 0 && chkpid != mproc.p_pid)
203	continue;
204	if (vflg && gflg == 0 && xflg == 0) {
205	if (mproc.p_stat == SZOMB)
206	continue;
207	if (mproc.p_slptime > MAXSLP &&
208	(mproc.p_stat == SSLEEP \|\| mproc.p_stat == SSTOP))
209	continue;
210	}
211	save();
212	}
213	qsort(savcom, npr, sizeof(savcom[0]), pscomp);
214	for (i=0; i<npr; i++) {
215	register struct savcom *sp = &savcom[i];
216	if (lflg)
217	lpr(sp);
218	else if (vflg)
219	vpr(sp);
220	else if (uflg)
221	upr(sp);
222	else
223	spr(sp);
224	if (sp->ap->a_pid == 0)
225	printf(" swapper");
226	else if (sp->ap->a_pid == 2)
227	printf(" pagedaemon");
228	else
229	printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
230	printf("\n");
231	}
232	exit(npr == 0);
233	}
234
235	openfiles(argc, argv)
236	char **argv;
237	{
238
239	kmemf = "/dev/kmem";
240	if (kflg)
241	kmemf = argc > 1 ? argv[1] : "/vmcore";
242	kmem = open(kmemf, 0);
243	if (kmem < 0) {
244	perror(kmemf);
245	exit(1);
246	}
247	if (kflg) {
248	mem = kmem;
249	memf = kmemf;
250	} else {
251	memf = "/dev/mem";
252	mem = open(memf, 0);
253	if (mem < 0) {
254	perror(memf);
255	exit(1);
256	}
257	}
258	swapf = argc>2 ? argv[2]: "/dev/drum";
259	swap = open(swapf, 0);
260	if (swap < 0) {
261	perror(swapf);
262	exit(1);
263	}
264	}
265
266	getkvars(argc, argv)
267	char **argv;
268	{
269	register struct nlist *nlp;
270
271	nlistf = argc > 3 ? argv[3] : "/vmunix";
272	nlist(nlistf, nl);
273	if (nl[0].n_type == 0) {
274	fprintf(stderr, "%s: No namelist\n", nlistf);
275	exit(1);
276	}
277	if (chdir("/dev") < 0) {
278	perror("/dev");
279	exit(1);
280	}
281	if (kflg)
282	for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
283	nlp->n_value = clear(nlp->n_value);
284	Usrptma = (struct pte *)nl[X_USRPTMA].n_value;
285	usrpt = (struct pte *)nl[X_USRPT].n_value;
286	lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
287	if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
288	/###287 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(287)%%%/
289	cantread("nswap", kmemf);
290	/###288 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(288)%%%/
291	/###288 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(288)%%%/
292	exit(1);
293	}
294	if (vflg) {
295	text = (struct text )alloc(NTEXT sizeof (struct text));
296	if (text == 0) {
297	fprintf(stderr, "no room for text table\n");
298	exit(1);
299	}
300	lseek(kmem, (long)nl[X_TEXT].n_value, 0);
301	if (read(kmem, text, sizeof (text)) != sizeof (text)) {
302	/###298 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(298)%%%/
303	cantread("text table", kmemf);
304	/###299 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(299)%%%/
305	/###299 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(299)%%%/
306	exit(1);
307	}
308	}
309	}
310
311	printhdr()
312	{
313	char *hdr;
314
315	if (sflg+lflg+vflg+uflg > 1) {
316	fprintf(stderr, "ps: specify only one of s,l,v and u\n");
317	exit(1);
318	}
319	hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr));
320	if (lflg+vflg+uflg+sflg == 0)
321	hdr += strlen(" SSIZ");
322	cmdstart = strlen(hdr);
323	printf("%s COMMAND\n", hdr);
324	fflush(stdout);
325	}
326
327	cantread(what, fromwhat)
328	char what, fromwhat;
329	{
330
331	fprintf(stderr, "ps: error reading %s from %s", what, fromwhat);
332	}
333
334	getdev()
335	{
336	register FILE *df;
337	struct stat sbuf;
338	struct direct dbuf;
339
340	if ((df = fopen("/dev", "r")) == NULL) {
341	fprintf(stderr, "Can't open /dev\n");
342	exit(1);
343	}
344	ndev = 0;
345	while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
346	if (dbuf.d_ino == 0)
347	continue;
348	if (stat(dbuf.d_name, &sbuf) < 0)
349	continue;
350	if ((sbuf.st_mode&S_IFMT) != S_IFCHR)
351	continue;
352	strcpy(devl[ndev].dname, dbuf.d_name);
353	devl[ndev].dev = sbuf.st_rdev;
354	ndev++;
355	}
356	fclose(df);
357	}
358
359	save()
360	{
361	register struct savcom *sp;
362	register struct asav *ap;
363	register char *cp;
364	char ttyp, cmdp;
365
366	if (mproc.p_stat != SZOMB && getu() == 0)
367	return;
368	ttyp = gettty();
369	if (tptr && strcmpn(tptr, ttyp, 2))
370	return;
371	sp = &savcom[npr];
372	cmdp = getcmd();
373	if (cmdp == 0)
374	return;
375	sp->ap = ap = (struct asav *)alloc(sizeof (struct asav));
376	sp->ap->a_cmdp = cmdp;
377	#define e(a,b) ap->a = mproc.b
378	e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice);
379	e(a_uid, p_uid); e(a_pid, p_pid); e(a_rss, p_rssize);
380	#undef e
381	ap->a_size = mproc.p_dsize + mproc.p_ssize;
382	ap->a_tty[0] = ttyp[0];
383	ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' ';
384	ap->a_ttyd = u.u_ttyd;
385	ap->a_time = u.u_vm.vm_utime + u.u_vm.vm_stime;
386	if (lflg) {
387	register struct lsav *lp;
388
389	sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav));
390	#define e(a,b) lp->a = mproc.b
391	e(l_ppid, p_ppid); e(l_cpu, p_cpu);
392	e(l_pri, p_pri); e(l_wchan, p_wchan);
393	#undef e
394	lp->l_addr = pcbpf;
395	} else if (vflg) {
396	register struct vsav *vp;
397	register struct text *xp;
398
399	sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav));
400	#define e(a,b) vp->a = mproc.b
401	e(v_slptime, p_slptime); e(v_pri, p_pri);
402	e(v_swrss, p_swrss); e(v_aveflt, p_aveflt);
403	#undef e
404	vp->v_minflt = u.u_vm.vm_minflt;
405	vp->v_majflt = u.u_vm.vm_majflt;
406	if (mproc.p_textp) {
407	xp = &text[mproc.p_textp -
408	(struct text *)nl[X_TEXT].n_value];
409	vp->v_tsiz = xp->x_size;
410	vp->v_txtrss = xp->x_rssize;
411	vp->v_txtswrss = xp->x_swrss;
412	vp->v_xccount = xp->x_ccount;
413	} else {
414	vp->v_tsiz = 0;
415	vp->v_txtrss = 0;
416	vp->v_xccount = 0;
417	vp->v_txtswrss = 0;
418	}
419	} else if (uflg)
420	sp->sun.u_pctcpu = 0.0;
421	else if (sflg) {
422	for (cp = (char *)u.u_stack;
423	cp < (char *)&u + ctob(UPAGES); )
424	if (*cp++)
425	break;
426	sp->sun.s_ssiz = (int) ((char *)&u + ctob(UPAGES) - cp);
427	}
428	npr++;
429	}
430
431	getu()
432	{
433	struct pte *pteaddr, apte, arguutl[UPAGES+CLSIZE];
434	register int i;
435	int ncl, size;
436
437	size = sflg ? ctob(UPAGES) : sizeof (struct user);
438	if ((mproc.p_flag & SLOAD) == 0) {
439	lseek(swap, ctob(mproc.p_swaddr), 0);
440	if (read(swap, (char *)&u, size) != size) {
441	fprintf(stderr, "ps: cant read u for pid %d from %s\n",
442	mproc.p_pid, swapf);
443	return (0);
444	}
445	pcbpf = 0;
446	argaddr = 0;
447	return (1);
448	}
449	pteaddr = &Usrptma[btokmx(mproc.p_p0br) + mproc.p_szpt - 1];
450	lseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0);
451	if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
452	printf("ps: cant read indir pte to get u for pid %d from %s\n",
453	mproc.p_pid, swapf);
454	return (0);
455	}
456	lseek(mem,
457	ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
458	if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
459	printf("ps: cant read page table for u of pid %d from %s\n",
460	mproc.p_pid, swapf);
461	return (0);
462	}
463	if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
464	argaddr = ctob(arguutl[0].pg_pfnum);
465	else
466	argaddr = 0;
467	pcbpf = arguutl[CLSIZE].pg_pfnum;
468	ncl = (size + NBPGCLSIZE - 1) / (NBPGCLSIZE);
469	while (--ncl >= 0) {
470	i = ncl * CLSIZE;
471	lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
472	if (read(mem, user.upages[CLSIZE+i], CLSIZE*NBPG)
473	!= CLSIZE*NBPG) {
474	printf("ps: cant read page %d of u of pid %d from %s\n",
475	arguutl[CLSIZE+i].pg_pfnum, mproc.p_pid, memf);
476	return(0);
477	}
478	}
479	return (1);
480	}
481
482	char *
483	getcmd()
484	{
485	char cmdbuf[BUFSIZ];
486	union {
487	char argc[CLSIZE*NBPG];
488	int argi[CLSIZE*NBPG/sizeof (int)];
489	} argspac;
490	register char *cp;
491	register int *ip;
492	char c;
493	int nbad;
494	struct dblock db;
495
496	if (mproc.p_stat == SZOMB)
497	return ("");
498	if (cflg)
499	goto retucomm;
500	if ((mproc.p_flag & SLOAD) == 0 \|\| argaddr == 0) {
501	vstodb(0, CLSIZE, &u.u_smap, &db, 1);
502	lseek(swap, ctob(db.db_base), 0);
503	if (read(swap, (char *)&argspac, sizeof(argspac))
504	!= sizeof(argspac))
505	goto bad;
506	} else {
507	lseek(mem, argaddr, 0);
508	if (read(mem, (char *)&argspac, sizeof (argspac))
509	!= sizeof (argspac))
510	goto bad;
511	}
512	ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
513	*--ip = 0;
514	while (*--ip)
515	if (ip == argspac.argi)
516	goto retucomm;
517	(char )ip = ' ';
518	ip++;
519	nbad = 0;
520	for (cp = (char )ip; cp < &argspac.argc[CLSIZENBPG]; cp++) {
521	c = *cp & 0177;
522	if (c == 0)
523	*cp = ' ';
524	else if (c < ' ' \|\| c > 0176) {
525	if (++nbad >= 5) {
526	*cp++ = ' ';
527	break;
528	}
529	*cp = '?';
530	} else if (c == '=') {
531	while (*--cp != ' ')
532	if (cp <= (char *)ip)
533	break;
534	break;
535	}
536	}
537	*cp = 0;
538	while (*--cp == ' ')
539	*cp = 0;
540	cp = (char *)ip;
541	strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
542	if (cp[0] == '-' \|\| cp[0] == '?' \|\| cp[0] <= ' ') {
543	strcat(cp, " (");
544	strncat(cp, u.u_comm, sizeof(u.u_comm));
545	strcat(cp, ")");
546	}
547	if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-')
548	return (0);
549	return (savestr(cmdbuf));
550
551	bad:
552	fprintf(stderr, "ps: error locating command name for pid %d\n",
553	mproc.p_pid);
554	retucomm:
555	strcat(cp, " (");
556	strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm));
557	strcat(cp, ")");
558	return (savestr(cmdbuf));
559	}
560
561	char *lhdr =
562	" F S UID PID PPID CP PRI NICE ADDR SZ RSS WCHAN TTY TIME";
563	lpr(sp)
564	struct savcom *sp;
565	{
566	register struct asav *ap = sp->ap;
567	register struct lsav *lp = sp->sun.lp;
568
569	printf("%5x %c %4d%5u%6u%3d%4d%4d%6x%4d%5d",
570	ap->a_flag, "0SWRIZT"[ap->a_stat], ap->a_uid,
571	ap->a_pid, lp->l_ppid, lp->l_cpu&0377, lp->l_pri-PZERO,
572	ap->a_nice-NZERO, lp->l_addr, ap->a_size, ap->a_rss);
573	printf(lp->l_wchan ? "%6x" : " ", lp->l_wchan);
574	ptty(ap->a_tty);
575	ptime(ap);
576	}
577
578	ptty(tp)
579	char *tp;
580	{
581
582	printf(" %-2.2s", tp);
583	}
584
585	ptime(ap)
586	struct asav *ap;
587	{
588
589	if (ap->a_stat == SZOMB)
590	printf(" <defunct>");
591	else
592	printf("%3ld:%02ld", ap->a_time / HZ, ap->a_time % HZ);
593	}
594
595	char *uhdr =
596	"USER PID %%CPU NICE SZ RSS TTY TIME";
597	upr(sp)
598	struct savcom *sp;
599	{
600	register struct asav *ap = sp->ap;
601
602	printf("%-8.8s%5u%5.1f%4d%4d%5d",
603	getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, ap->a_nice,
604	ap->a_size, ap->a_rss);
605	ptty(ap->a_tty);
606	ptime(ap);
607	}
608
609	char *vhdr =
610	"F PID TT TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF";
611	vpr(sp)
612	struct savcom *sp;
613	{
614	register struct vsav *vp = sp->sun.vp;
615	register struct asav *ap = sp->ap;
616	char stat, nice, anom;
617
618	switch (ap->a_stat) {
619
620	case SSLEEP:
621	case SSTOP:
622	if ((ap->a_flag & SLOAD) == 0)
623	stat = 'W';
624	else if (vp->v_pri >= PZERO)
625	stat = 'S';
626	else if (ap->a_flag & SPAGE)
627	stat = 'P';
628	else
629	stat = 'D';
630	break;
631
632	case SRUN:
633	case SIDL:
634	stat = ap->a_flag & SLOAD ? 'R' : 'W';
635	break;
636	}
637	nice = ap->a_nice > NZERO ? 'N' : ' ';
638	anom = ap->a_flag & (SANOM\|SUANOM) ? 'A' : ' ';
639	printf("%c%c%c%5u", stat, nice, anom, ap->a_pid);
640	ptty(ap->a_tty);
641	ptime(ap);
642	printf("%3d%3d%8d%8d%5d%5d%5d%5d%4d%3d",
643	ap->a_time, vp->v_slptime, vp->v_majflt, vp->v_minflt,
644	ap->a_size, ap->a_rss, vp->v_swrss, vp->v_tsiz, vp->v_txtrss,
645	vp->v_aveflt);
646	}
647
648	char *shdr =
649	" SSIZ PID TTY TIME";
650	spr(sp)
651	struct savcom *sp;
652	{
653	register struct asav *ap = sp->ap;
654
655	if (sflg)
656	printf("%5d", sp->sun.s_ssiz);
657	printf(" %5u", ap->a_pid);
658	ptty(ap->a_tty);
659	ptime(ap);
660	}
661
662	char *
663	gettty()
664	{
665	register i;
666	register char *p;
667
668	if (u.u_ttyp == 0)
669	return("?");
670	for (i=0; i<ndev; i++) {
671	if (devl[i].dev == u.u_ttyd) {
672	p = devl[i].dname;
673	if (p[0]=='t' && p[1]=='t' && p[2]=='y')
674	p += 3;
675	return(p);
676	}
677	}
678	return("?");
679	}
680
681	/*
682	* Given a base/size pair in virtual swap area,
683	* return a physical base/size pair which is the
684	* (largest) initial, physically contiguous block.
685	*/
686	vstodb(vsbase, vssize, dmp, dbp, rev)
687	register int vsbase;
688	int vssize;
689	struct dmap *dmp;
690	register struct dblock *dbp;
691	{
692	register int blk = DMMIN;
693	register swblk_t *ip = dmp->dm_map;
694
695	if (vsbase < 0 \|\| vsbase + vssize > dmp->dm_size)
696	panic("vstodb");
697	while (vsbase >= blk) {
698	vsbase -= blk;
699	if (blk < DMMAX)
700	blk *= 2;
701	ip++;
702	}
703	if (ip <= 0 \|\| ip + blk > nswap)
704	panic("vstodb *ip");
705	dbp->db_size = min(vssize, blk - vsbase);
706	dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
707	}
708
709	/ARGSUSED/
710	panic(cp)
711	char *cp;
712	{
713
714	#ifdef DEBUG
715	printf("%s\n", cp);
716	#endif
717	}
718
719	min(a, b)
720	{
721
722	return (a < b ? a : b);
723	}
724
725	pscomp(s1, s2)
726	struct savcom s1, s2;
727	{
728	register int i;
729
730	if (vflg)
731	return (vsize(s2) - vsize(s1));
732	i = s1->ap->a_ttyd - s2->ap->a_ttyd;
733	if (i == 0)
734	i = s1->ap->a_pid - s2->ap->a_pid;
735	return (i);
736	}
737
738	vsize(sp)
739	struct savcom *sp;
740	{
741	register struct asav *ap = sp->ap;
742	register struct vsav *vp = sp->sun.vp;
743
744	if (ap->a_flag & SLOAD)
745	return (ap->a_rss +
746	vp->v_txtrss / (vp->v_xccount ? vp->v_xccount : 1));
747	return (vp->v_swrss + (vp->v_xccount ? 0 : vp->v_txtswrss));
748	}
749
750	#define NMAX 8
751	#define NUID 2048
752
753	char names[NUID][NMAX+1];
754
755	/*
756	* Stolen from ls...
757	*/
758	char *
759	getname(uid)
760	{
761	register struct passwd *pw;
762	static init;
763	struct passwd *getpwent();
764
765	if (names[uid][0])
766	return (&names[uid][0]);
767	if (init == 2)
768	return (0);
769	if (init == 0)
770	setpwent(), init = 1;
771	while (pw = getpwent()) {
772	if (pw->pw_uid >= NUID)
773	continue;
774	if (names[pw->pw_uid][0])
775	continue;
776	strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
777	if (pw->pw_uid == uid)
778	return (&names[uid][0]);
779	}
780	init = 2;
781	endpwent();
782	return (0);
783	}
784
785	char *freebase;
786	int nleft;
787
788	char *
789	alloc(size)
790	int size;
791	{
792	register char *cp;
793	register int i;
794
795	if (size > nleft) {
796	freebase = (char *)sbrk(size > 2048 ? size : 2048);
797	if (freebase == 0) {
798	fprintf(stderr, "ps: ran out of memory\n");
799	exit(1);
800	}
801	}
802	cp = freebase;
803	for (i = size; --i >= 0; )
804	*cp++ = 0;
805	freebase = cp;
806	return (cp - size);
807	}
808
809	char *
810	savestr(cp)
811	char *cp;
812	{
813	register int len;
814	register char *dp;
815
816	len = strlen(cp);
817	dp = (char *)alloc(len+1);
818	strcpy(dp, cp);
819	return (dp);
820	}