X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/ceb20920a4dee11c977636aaa1073af42a55b49e..c223880f1d3c80acd7d7e3388e1d2cce1e225fa5:/usr/src/bin/ps/ps.c

diff --git a/usr/src/bin/ps/ps.c b/usr/src/bin/ps/ps.c
index e3a5c89c08..832f79e20d 100644
--- a/usr/src/bin/ps/ps.c
+++ b/usr/src/bin/ps/ps.c
@@ -1,13 +1,22 @@
-#ifndef lint
-static	char *sccsid = "@(#)ps.c	4.31 (Berkeley) %G%";
-#endif
-
 /*
- * ps
+ * 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
+char copyright[] =
+"@(#) Copyright (c) 1980 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif not lint
+
+#ifndef lint
+static char sccsid[] = "@(#)ps.c	5.4 (Berkeley) %G%";
+#endif not lint
+
 #include <stdio.h>
 #include <ctype.h>
-#include <nlist.h>
+#include <a.out.h>
 #include <pwd.h>
 #include <sys/param.h>
 #include <sys/ioctl.h>
@@ -23,38 +32,71 @@ static	char *sccsid = "@(#)ps.c	4.31 (Berkeley) %G%";
 #include <math.h>
 #include <errno.h>
 
-struct nlist nl[] = {
-	{ "_proc" },
+char *nl_names[] = {
+	"_proc",
 #define	X_PROC		0
-	{ "_Usrptmap" },
+	"_Usrptmap",
 #define	X_USRPTMAP	1
-	{ "_usrpt" },
+	"_usrpt",
 #define	X_USRPT		2
-	{ "_text" },
+	"_text",
 #define	X_TEXT		3
-	{ "_nswap" },
+	"_nswap",
 #define	X_NSWAP		4
-	{ "_maxslp" },
+	"_maxslp",
 #define	X_MAXSLP	5
-	{ "_ccpu" },
+	"_ccpu",
 #define	X_CCPU		6
-	{ "_ecmx" },
+	"_ecmx",
 #define	X_ECMX		7
-	{ "_nproc" },
+	"_nproc",
 #define	X_NPROC		8
-	{ "_ntext" },
+	"_ntext",
 #define	X_NTEXT		9
-	{ "_dmmin" },
+	"_dmmin",
 #define	X_DMMIN		10
-	{ "_dmmax" },
+	"_dmmax",
 #define	X_DMMAX		11
-	{ "_Sysmap" },
+	"_Sysmap",
 #define	X_SYSMAP	12
-	{ "_Syssize" },
+	"_Syssize",
 #define	X_SYSSIZE	13
-	{ "" },
+	"_inode",
+#define X_INODE		14
+	"_file",
+#define X_FILE		15
+	"_cfree",
+#define X_CFREE		16
+	"_callout",
+#define X_CALLOUT	17
+	"_swapmap",
+#define X_SWAPMAP	18
+	"_argmap",
+#define X_ARGMAP	19
+	"_kernelmap",
+#define X_KERNELMAP	20
+	"_mbmap",
+#define X_MBMAP		21
+	"_nch",
+#define X_NCH		22
+	"_quota",
+#define X_QUOTA		23
+	"_dquot",
+#define X_DQUOT		24
+	"_swbuf",
+#define X_SWBUF		25
+	"_buf",
+#define X_BUF		26
+	"_cmap",
+#define X_CMAP		27
+	"_buffers",
+#define X_BUFFERS	28
+	""
 };
 
+struct nlist *nl;			/* all because we can't init unions */
+int nllen;				/* # of nlist entries */
+
 struct	savcom {
 	union {
 		struct	lsav *lp;
@@ -78,6 +120,7 @@ struct	asav {
 };
 
 char	*lhdr;
+int	wcwidth;		/* width of the wchan field for sprintf*/
 struct	lsav {
 	short	l_ppid;
 	char	l_cpu;
@@ -114,15 +157,18 @@ char	*psdb	= PSFILE;
 #endif
 
 int	chkpid;
-int	aflg, cflg, eflg, gflg, kflg, lflg, sflg,
+int	aflg, cflg, eflg, gflg, kflg, lflg, nflg, sflg,
 	uflg, vflg, xflg, Uflg;
+int	nchans;				/* total # of wait channels */
 char	*tptr;
 char	*gettty(), *getcmd(), *getname(), *savestr(), *state();
 char	*rindex(), *calloc(), *sbrk(), *strcpy(), *strcat(), *strncat();
-char	*strncpy(), *index(), *ttyname(), mytty[16];
+char	*strncpy(), *index(), *ttyname(), mytty[MAXPATHLEN+1];
+char	*malloc(), *getchan();
 long	lseek();
 off_t	vtophys();
 double	pcpu(), pmem();
+int	wchancomp();
 int	pscomp();
 int	nswap, maxslp;
 struct	text *atext;
@@ -134,17 +180,50 @@ int	dmmin, dmmax;
 struct	pte *Sysmap;
 int	Syssize;
 
-#ifndef	MAXTTYS
-#define	MAXTTYS		256
-#endif
-
 int	nttys;
 
 struct	ttys {
 	dev_t	ttyd;
-	struct	ttys *cand;
+	int cand;
 	char	name[MAXNAMLEN+1];
-} allttys[MAXTTYS], *cand[16];
+} *allttys;
+int cand[16] = {-1, -1, -1, -1, -1, -1, -1, -1,
+		-1, -1, -1, -1, -1, -1, -1, -1};
+struct lttys {
+	struct ttys ttys;
+	struct lttys *next;
+} *lallttys;
+
+/*
+ * struct for the symbolic wait channel info
+ *
+ * WNAMESIZ is the max # of chars saved of the symbolic wchan gleaned
+ * from the namelist.  Normally, only WSNAMESIZ are printed in the long
+ * format, unless the terminal width is greater than WTSIZ wide.
+ */
+#define WNAMESIZ	12
+#define WSNAMESIZ	6
+#define WTSIZ		95
+
+struct wchan {
+	char	wc_name[WNAMESIZ+1];	/* symbolic name */
+	caddr_t wc_caddr;		/* addr in kmem */
+} *wchanhd;				/* an array sorted by wc_caddr */
+
+#define NWCINDEX	10		/* the size of the index array */
+
+caddr_t wchan_index[NWCINDEX];		/* used to speed searches */
+/*
+ * names listed here are not kept as wait channels -- this is used to 
+ * remove names that confuse ps, like symbols that define the end of an
+ * array that happen to be equal to the next symbol.
+ */
+char *wchan_stop_list[] = {
+	"umbabeg",
+	"umbaend",
+	"calimit",
+	NULL
+};
 
 int	npr;
 
@@ -207,17 +286,22 @@ main(argc, argv)
 		case 'l':
 			lflg++;
 			break;
+		case 'n':
+			nflg++;
+			break;
 		case 's':
 			sflg++;
 			break;
 		case 't':
 			if (*ap)
 				tptr = ap;
-			else if ((tptr = ttyname(2)) != 0) {
-				strcpy(mytty, tptr);
-				if ((tptr = index(mytty,'y')) != 0)
-					tptr++;
+			else if ((tptr = ttyname(0)) != 0) {
+				tptr = strcpy(mytty, tptr);
+				if (strncmp(tptr, "/dev/", 5) == 0)
+					tptr += 5;
 			}
+			if (strncmp(tptr, "tty", 3) == 0)
+				tptr += 3;
 			aflg++;
 			gflg++;
 			if (tptr && *tptr == '?')
@@ -307,16 +391,14 @@ main(argc, argv)
 			upr(sp);
 		else
 			spr(sp);
-		if (sp->ap->a_flag & SWEXIT)
-			printf(" <exiting>");
-		else if (sp->ap->a_stat == SZOMB)
+		if (sp->ap->a_stat == SZOMB)
 			printf(" <defunct>");
+		else if (sp->ap->a_flag & SWEXIT)
+			printf(" <exiting>");
 		else if (sp->ap->a_pid == 0)
 			printf(" swapper");
 		else if (sp->ap->a_pid == 2)
 			printf(" pagedaemon");
-		else if (sp->ap->a_pid == 3 && sp->ap->a_flag & SSYS)
-			printf(" ip input");
 		else
 			printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
 		printf("\n");
@@ -350,20 +432,25 @@ klseek(fd, loc, off)
 writepsdb(unixname)
 	char *unixname;
 {
-	int nllen;
 	register FILE *fp;
+	struct lttys *lt;
 
+	setgid(getgid());
 	setuid(getuid());
 	if ((fp = fopen(psdb, "w")) == NULL) {
 		perror(psdb);
 		exit(1);
 	} else
 		fchmod(fileno(fp), 0644);
-	nllen = sizeof nl / sizeof (struct nlist);
 	fwrite((char *) &nllen, sizeof nllen, 1, fp);
 	fwrite((char *) nl, sizeof (struct nlist), nllen, fp);
+	fwrite((char *) cand, sizeof (cand), 1, fp);
 	fwrite((char *) &nttys, sizeof nttys, 1, fp);
-	fwrite((char *) allttys, sizeof (struct ttys), nttys, fp);
+	for (lt = lallttys ; lt ; lt = lt->next)
+		fwrite((char *)&lt->ttys, sizeof (struct ttys), 1, fp);
+	fwrite((char *) &nchans, sizeof nchans, 1, fp);
+	fwrite((char *) wchanhd, sizeof (struct wchan), nchans, fp);
+	fwrite((char *) wchan_index, sizeof (caddr_t), NWCINDEX, fp);
 	fwrite(unixname, strlen(unixname) + 1, 1, fp);
 	fclose(fp);
 }
@@ -371,7 +458,6 @@ writepsdb(unixname)
 readpsdb(unixname)
 	char *unixname;
 {
-	int nllen;
 	register i;
 	register FILE *fp;
 	char unamebuf[BUFSIZ];
@@ -386,9 +472,25 @@ readpsdb(unixname)
 	}
 
 	fread((char *) &nllen, sizeof nllen, 1, fp);
+	nl = (struct nlist *) malloc (nllen * sizeof (struct nlist));
 	fread((char *) nl, sizeof (struct nlist), nllen, fp);
+	fread((char *) cand, sizeof (cand), 1, fp);
 	fread((char *) &nttys, sizeof nttys, 1, fp);
+	allttys = (struct ttys *)malloc(sizeof(struct ttys)*nttys);
+	if (allttys == NULL) {
+		fprintf(stderr, "ps: Can't malloc space for tty table\n");
+		exit(1);
+	}
 	fread((char *) allttys, sizeof (struct ttys), nttys, fp);
+	fread((char *) &nchans, sizeof nchans, 1, fp);
+	wchanhd = (struct wchan *) malloc(nchans * sizeof (struct wchan));
+	if (wchanhd == NULL) {
+		fprintf(stderr, "ps: Can't malloc space for wait channels\n");
+		nflg++;
+		fseek(fp, (long) nchans * sizeof (struct wchan), 1);
+	} else
+		fread((char *) wchanhd, sizeof (struct wchan), nchans, fp);
+	fread((char *) wchan_index, sizeof (caddr_t), NWCINDEX, fp);
 	while ((*p = getc(fp)) != '\0')
 		p++;
 	return (strcmp(unixname, unamebuf) == 0);
@@ -430,18 +532,23 @@ openfiles(argc, argv)
 getkvars(argc, argv)
 	char **argv;
 {
+	int faildb = 0;			/* true if psdatabase init failed */
 
 	nlistf = argc > 1 ? argv[1] : "/vmunix";
 	if (Uflg) {
+		init_nlist();
 		nlist(nlistf, nl);
+		getvchans();
 		getdev();
 		writepsdb(nlistf);
 		exit (0);
 	} else if (!readpsdb(nlistf)) {
+		init_nlist();
 		if (!kflg)
-			nl[X_SYSMAP].n_name = "";
+			nl[X_SYSMAP].n_un.n_name = "";
+		faildb = 1;
 		nlist(nlistf, nl);
-		nttys =  0;
+		nttys = 0;
 		getdev();
 	}
 
@@ -465,6 +572,8 @@ getkvars(argc, argv)
 		(void) lseek(kmem, addr, 0);
 		read(kmem, (char *) Sysmap, Syssize * sizeof (struct pte));
 	}
+	if (faildb)
+		getvchans();
 	usrpt = (struct pte *)nl[X_USRPT].n_value;
 	Usrptmap = (struct pte *)nl[X_USRPTMAP].n_value;
 	klseek(kmem, (long)nl[X_NSWAP].n_value, 0);
@@ -507,6 +616,43 @@ getkvars(argc, argv)
 	dmmax = getw(nl[X_DMMAX].n_value);
 }
 
+/*
+ * get the valloc'ed kernel variables for symbolic wait channels
+ */
+getvchans()
+{
+	int i, tmp;
+
+	if (nflg)
+		return;
+
+#define addv(i) 	addchan(&nl[i].n_un.n_name[1], getw(nl[i].n_value))
+	addv(X_INODE);
+	addv(X_FILE);
+	addv(X_PROC);
+	addv(X_TEXT);
+	addv(X_CFREE);
+	addv(X_CALLOUT);
+	addv(X_SWAPMAP);
+	addv(X_ARGMAP);
+	addv(X_KERNELMAP);
+	addv(X_MBMAP);
+	addv(X_NCH);
+	if (nl[X_QUOTA].n_value != 0) {	/* these are #ifdef QUOTA */
+		addv(X_QUOTA);
+		addv(X_DQUOT);
+	}
+	addv(X_SWBUF);
+	addv(X_BUF);
+	addv(X_CMAP);
+	addv(X_BUFFERS);
+	qsort(wchanhd, nchans, sizeof (struct wchan), wchancomp);
+	for (i = 0; i < NWCINDEX; i++) {
+		tmp = i * nchans;
+		wchan_index[i] = wchanhd[tmp / NWCINDEX].wc_caddr;
+	}
+#undef addv
+}
 printhdr()
 {
 	char *hdr;
@@ -515,9 +661,29 @@ printhdr()
 		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) {
+		if (nflg)
+			wcwidth = 6;
+		else if (twidth > WTSIZ)
+			wcwidth = -WNAMESIZ;
+		else
+			wcwidth = -WSNAMESIZ;
+		if ((hdr = malloc(strlen(lhdr) + WNAMESIZ)) == NULL) {
+			fprintf(stderr, "ps: out of memory\n");
+			exit(1);
+		}
+		sprintf(hdr, lhdr, wcwidth, "WCHAN");
+	} else if (vflg)
+		hdr = vhdr;
+	else if (uflg) {
+		/* add enough on so that it can hold the sprintf below */
+		if ((hdr = malloc(strlen(uhdr) + 10)) == NULL) {
+			fprintf(stderr, "ps: out of memory\n");
+			exit(1);
+		}
+		sprintf(hdr, uhdr, nflg ? " UID" : "USER    ");
+	} else
+		hdr = shdr;
 	if (lflg+vflg+uflg+sflg == 0)
 		hdr += strlen("SSIZ ");
 	cmdstart = strlen(hdr);
@@ -538,6 +704,8 @@ int	dialbase;
 getdev()
 {
 	register DIR *df;
+	struct ttys *t;
+	struct lttys *lt;
 
 	if (chdir("/dev") < 0) {
 		perror("/dev");
@@ -551,6 +719,13 @@ getdev()
 	while ((dbuf = readdir(df)) != NULL) 
 		maybetty();
 	closedir(df);
+	allttys = (struct ttys *)malloc(sizeof(struct ttys)*nttys);
+	if (allttys == NULL) {
+		fprintf(stderr, "ps: Can't malloc space for tty table\n");
+		exit(1);
+	}
+	for (lt = lallttys, t = allttys; lt ; lt = lt->next, t++)
+		*t = lt->ttys;
 }
 
 /*
@@ -562,7 +737,8 @@ getdev()
 maybetty()
 {
 	register char *cp = dbuf->d_name;
-	register struct ttys *dp;
+	static struct lttys *dp;
+	struct lttys *olddp;
 	int x;
 	struct stat stb;
 
@@ -652,27 +828,40 @@ trymem:
 	else
 		x = -1;
 donecand:
-	if (nttys >= MAXTTYS) {
-		fprintf(stderr, "ps: tty table overflow\n");
+	olddp = dp;
+	dp = (struct lttys *)malloc(sizeof(struct lttys));
+	if (dp == NULL) {
+		fprintf(stderr, "ps: Can't malloc space for tty table\n");
 		exit(1);
 	}
-	dp = &allttys[nttys++];
-	(void) strcpy(dp->name, dbuf->d_name);
+	if (lallttys == NULL)
+		lallttys = dp;
+	nttys++;
+	if (olddp)
+		olddp->next = dp;
+	dp->next = NULL;
+	(void) strcpy(dp->ttys.name, dbuf->d_name);
 	if (Uflg) {
-		if (stat(dp->name, &stb) == 0 &&
+		if (stat(dp->ttys.name, &stb) == 0 &&
 		   (stb.st_mode&S_IFMT)==S_IFCHR)
-			dp->ttyd = x = stb.st_rdev;
+			dp->ttys.ttyd = x = stb.st_rdev;
 		else {
 			nttys--;
+			if (lallttys == dp)
+				lallttys = NULL;
+			free(dp);
+			dp = olddp;
+			if (dp)
+				dp->next = NULL;
 			return;
 		}
 	} else
-		dp->ttyd = -1;
+		dp->ttys.ttyd = -1;
 	if (x == -1)
 		return;
 	x &= 017;
-	dp->cand = cand[x];
-	cand[x] = dp;
+	dp->ttys.cand = cand[x];
+	cand[x] = nttys-1;
 }
 
 char *
@@ -686,7 +875,8 @@ gettty()
 	if (u.u_ttyp == 0)
 		return("?");
 	x = u.u_ttyd & 017;
-	for (dp = cand[x]; dp; dp = dp->cand) {
+	for (dp = &allttys[cand[x]]; dp != &allttys[-1];
+	     dp = &allttys[dp->cand]) {
 		if (dp->ttyd == -1) {
 			if (stat(dp->name, &stb) == 0 &&
 			   (stb.st_mode&S_IFMT)==S_IFCHR)
@@ -971,7 +1161,7 @@ retucomm:
 }
 
 char	*lhdr =
-"      F UID   PID  PPID CP PRI NI ADDR  SZ  RSS WCHAN  STAT TT  TIME";
+"      F UID   PID  PPID CP PRI NI ADDR  SZ  RSS %*s STAT TT  TIME";
 lpr(sp)
 	struct savcom *sp;
 {
@@ -982,7 +1172,12 @@ lpr(sp)
 	    ap->a_flag, ap->a_uid,
 	    ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO,
 	    ap->a_nice-NZERO, lp->l_addr, pgtok(ap->a_size), pgtok(ap->a_rss));
-	printf(lp->l_wchan ? " %6x" : "       ", (int)lp->l_wchan&0xffffff);
+	if (lp->l_wchan == 0)
+		printf(" %*s", wcwidth, "");
+	else if (nflg)
+		printf(" %*x", wcwidth, (int)lp->l_wchan&0xffffff);
+	else
+		printf(" %*.*s", wcwidth, abs(wcwidth), getchan(lp->l_wchan));
 	printf(" %4.4s ", state(ap));
 	ptty(ap->a_tty);
 	ptime(ap);
@@ -1003,7 +1198,7 @@ ptime(ap)
 }
 
 char	*uhdr =
-"USER       PID %CPU %MEM   SZ  RSS TT STAT  TIME";
+"%s   PID %%CPU %%MEM   SZ  RSS TT STAT  TIME";
 upr(sp)
 	struct savcom *sp;
 {
@@ -1014,9 +1209,12 @@ upr(sp)
 	rmsize = pgtok(ap->a_rss);
 	if (ap->a_xccount)
 		rmsize += pgtok(ap->a_txtrss/ap->a_xccount);
-	printf("%-8.8s %5d%5.1f%5.1f%5d%5d",
-	    getname(ap->a_uid), ap->a_pid, sp->s_un.u_pctcpu, pmem(ap),
-	    vmsize, rmsize);
+	if (nflg)
+		printf("%4d ", ap->a_uid);
+	else
+		printf("%-8.8s ", getname(ap->a_uid));
+	printf("%5d%5.1f%5.1f%5d%5d",
+	    ap->a_pid, sp->s_un.u_pctcpu, pmem(ap), vmsize, rmsize);
 	putchar(' ');
 	ptty(ap->a_tty);
 	printf(" %4.4s", state(ap));
@@ -1186,84 +1384,46 @@ vsize(sp)
 	return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss));
 }
 
-#define	NMAX	8	/* sizeof loginname (should be sizeof (utmp.ut_name)) */
-#define NUID	2048	/* must not be a multiple of 5 */
+#include <utmp.h>
 
-struct nametable {
-	char	nt_name[NMAX+1];
-	int	nt_uid;
-} nametable[NUID];
+struct	utmp utmp;
+#define	NMAX	(sizeof (utmp.ut_name))
+#define SCPYN(a, b)	strncpy(a, b, NMAX)
 
-struct nametable *
-findslot(uid)
-int	uid;
-{
-	register struct nametable	*n, *start;
-
-	/*
-	 * find the uid or an empty slot.
-	 * return NULL if neither found.
-	 */
-
-	n = start = nametable + (uid % (NUID - 20));
-	while (n->nt_name[0] && n->nt_uid != uid) {
-		if ((n += 5) >= &nametable[NUID])
-			n -= NUID;
-		if (n == start)
-			return((struct nametable *)NULL);
-	}
-	return(n);
-}
+#define NUID	64
 
+struct ncache {
+	int	uid;
+	char	name[NMAX+1];
+} nc[NUID];
+
+/*
+ * This function assumes that the password file is hashed
+ * (or some such) to allow fast access based on a uid key.
+ */
 char *
 getname(uid)
 {
-	register struct passwd		*pw;
-	static				init = 0;
-	struct passwd			*getpwent();
-	register struct nametable	*n;
-	extern int			_pw_stayopen;
-
-	/*
-	 * find uid in hashed table; add it if not found.
-	 * return pointer to name.
-	 */
-
-	if ((n = findslot(uid)) == NULL)
-		return((char *)NULL);
-
-	if (n->nt_name[0])	/* occupied? */
-		return(n->nt_name);
-
-	switch (init) {
-		case 0:
-			setpwent();
-			_pw_stayopen = 1;
-			init = 1;
-			/* intentional fall-thru */
-		case 1:
-			while (pw = getpwent()) {
-				if (pw->pw_uid < 0)
-					continue;
-				if ((n = findslot(pw->pw_uid)) == NULL) {
-					endpwent();
-					init = 2;
-					return((char *)NULL);
-				}
-				if (n->nt_name[0])
-					continue;	/* duplicate, not uid */
-				strncpy(n->nt_name, pw->pw_name, NMAX);
-				n->nt_uid = pw->pw_uid;
-				if (pw->pw_uid == uid)
-					return (n->nt_name);
-			}
-			endpwent();
-			init = 2;
-			/* intentional fall-thru */
-		case 2:
-			return ((char *)NULL);
-	}
-	/* NOTREACHED */
+	register struct passwd *pw;
+	struct passwd *getpwent();
+	register int cp;
+	extern int _pw_stayopen;
+
+	_pw_stayopen = 1;
+
+#if	(((NUID) & ((NUID) - 1)) != 0)
+	cp = uid % (NUID);
+#else
+	cp = uid & ((NUID) - 1);
+#endif
+	if (uid >= 0 && nc[cp].uid == uid && nc[cp].name[0])
+		return (nc[cp].name);
+	pw = getpwuid(uid);
+	if (!pw)
+		return (0);
+	nc[cp].uid = uid;
+	SCPYN(nc[cp].name, pw->pw_name);
+	return (nc[cp].name);
 }
 
 char *
@@ -1309,3 +1469,214 @@ long	loc;
 	loc = (long) (ptob(Sysmap[p].pg_pfnum) + (loc & PGOFSET));
 	return(loc);
 }
+
+/*
+ * since we can't init unions, the cleanest way to use a.out.h instead
+ * of nlist.h (required since nlist() uses some defines) is to do a
+ * runtime copy into the nl array -- sigh
+ */
+init_nlist()
+{
+	register struct nlist *np;
+	register char **namep;
+
+	nllen = sizeof nl_names / sizeof (char *);
+	np = nl = (struct nlist *) malloc(nllen * sizeof (struct nlist));
+	if (np == NULL) {
+		fprintf(stderr, "ps: out of memory allocating namelist\n");
+		exit(1);
+	}
+	namep = &nl_names[0];
+	while (nllen > 0) {
+		np->n_un.n_name = *namep;
+		if (**namep == '\0')
+			break;
+		namep++;
+		np++;
+	}
+}
+
+/*
+ * nlist - retreive attributes from name list (string table version)
+ * 	modified to add wait channels - Charles R. LaBrec 8/85
+ */
+nlist(name, list)
+	char *name;
+	struct nlist *list;
+{
+	register struct nlist *p, *q;
+	register char *s1, *s2;
+	register n, m;
+	int maxlen, nreq;
+	FILE *f;
+	FILE *sf;
+	off_t sa;		/* symbol address */
+	off_t ss;		/* start of strings */
+	int type;
+	struct exec buf;
+	struct nlist space[BUFSIZ/sizeof (struct nlist)];
+	char nambuf[BUFSIZ];
+
+	maxlen = 0;
+	for (q = list, nreq = 0; q->n_un.n_name && q->n_un.n_name[0]; q++, nreq++) {
+		q->n_type = 0;
+		q->n_value = 0;
+		q->n_desc = 0;
+		q->n_other = 0;
+		n = strlen(q->n_un.n_name);
+		if (n > maxlen)
+			maxlen = n;
+	}
+	f = fopen(name, "r");
+	if (f == NULL)
+		return (-1);
+	fread((char *)&buf, sizeof buf, 1, f);
+	if (N_BADMAG(buf)) {
+		fclose(f);
+		return (-1);
+	}
+	sf = fopen(name, "r");
+	if (sf == NULL) {
+		/* ??? */
+		fclose(f);
+		return(-1);
+	}
+	sa = N_SYMOFF(buf);
+	ss = sa + buf.a_syms;
+	n = buf.a_syms;
+	fseek(f, sa, 0);
+	while (n) {
+		m = sizeof (space);
+		if (n < m)
+			m = n;
+		if (fread((char *)space, m, 1, f) != 1)
+			break;
+		n -= m;
+		for (q = space; (m -= sizeof(struct nlist)) >= 0; q++) {
+			if (q->n_un.n_strx == 0 || q->n_type & N_STAB)
+				continue;
+			/*
+			 * since we know what type of symbols we will get,
+			 * we can make a quick check here -- crl
+			 */
+			type = q->n_type & (N_TYPE | N_EXT);
+			if ((q->n_type & N_TYPE) != N_ABS
+			    && type != (N_EXT | N_DATA)
+			    && type != (N_EXT | N_BSS))
+				continue;
+			fseek(sf, ss+q->n_un.n_strx, 0);
+			fread(nambuf, maxlen+1, 1, sf);
+			/* if using wchans, add it to the list of channels */
+			if (!nflg)
+				addchan(&nambuf[1], (caddr_t) q->n_value);
+			for (p = list; p->n_un.n_name && p->n_un.n_name[0]; p++) {
+				s1 = p->n_un.n_name;
+				s2 = nambuf;
+				if (strcmp(p->n_un.n_name, nambuf) == 0) {
+					p->n_value = q->n_value;
+					p->n_type = q->n_type;
+					p->n_desc = q->n_desc;
+					p->n_other = q->n_other;
+					--nreq;
+					break;
+				}
+			}
+		}
+	}
+alldone:
+	fclose(f);
+	fclose(sf);
+	return (nreq);
+}
+
+/*
+ * add the given channel to the channel list
+ */
+addchan(name, caddr)
+char *name;
+caddr_t caddr;
+{
+	static int left = 0;
+	register struct wchan *wp;
+	register char **p;
+
+	for (p = wchan_stop_list; *p; p++) {
+		if (**p != *name)	/* quick check first */
+			continue;
+		if (strncmp(name, *p, WNAMESIZ) == 0)
+			return;		/* if found, don't add */
+	}
+	if (left == 0) {
+		if (wchanhd) {
+			left = 100;
+			wchanhd = (struct wchan *) realloc(wchanhd,
+				(nchans + left) * sizeof (struct wchan));
+		} else {
+			left = 600;
+			wchanhd = (struct wchan *) malloc(left
+				* sizeof (struct wchan));
+		}
+		if (wchanhd == NULL) {
+			fprintf(stderr, "ps: out of memory allocating wait channels\n");
+			nflg++;
+			return;
+		}
+	}
+	left--;
+	wp = &wchanhd[nchans++];
+	strncpy(wp->wc_name, name, WNAMESIZ);
+	wp->wc_name[WNAMESIZ] = '\0';
+	wp->wc_caddr = caddr;
+}
+
+/*
+ * returns the symbolic wait channel corresponding to chan
+ */
+char *
+getchan(chan)
+register caddr_t chan;
+{
+	register i, iend;
+	register char *prevsym;
+	register struct wchan *wp;
+
+	prevsym = "???";		/* nothing, to begin with */
+	if (chan) {
+		for (i = 0; i < NWCINDEX; i++)
+			if ((unsigned) chan < (unsigned) wchan_index[i])
+				break;
+		iend = i--;
+		if (i < 0)		/* can't be found */
+			return prevsym;
+		iend *= nchans;
+		iend /= NWCINDEX;
+		i *= nchans;
+		i /= NWCINDEX;
+		wp = &wchanhd[i];
+		for ( ; i < iend; i++, wp++) {
+			if ((unsigned) wp->wc_caddr > (unsigned) chan)
+				break;
+			prevsym = wp->wc_name;
+		}
+	}
+	return prevsym;
+}
+
+/*
+ * used in sorting the wait channel array
+ */
+int
+wchancomp (w1, w2)
+struct wchan *w1, *w2;
+{
+	register unsigned c1, c2;
+
+	c1 = (unsigned) w1->wc_caddr;
+	c2 = (unsigned) w2->wc_caddr;
+	if (c1 > c2)
+		return 1;
+	else if (c1 == c2)
+		return 0;
+	else
+		return -1;
+}