[unix-history] / usr / src / cmd / ps.c

/*
 *	ps - process status
 *	examine and print certain things about processes
 */

#include <stdio.h>
#include <a.out.h>
#include <core.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/tty.h>
#include <sys/dir.h>
#include <sys/user.h>

struct nlist nl[] = {
	{ "_proc" },
	{ "_swapdev" },
	{ "_swplo" },
	{ "" },
};

struct	proc mproc;

struct	user u;
int	chkpid;
int	retcode=1;
int	lflg;
int	vflg;
int	kflg;
int	xflg;
char	*tptr;
long	lseek();
char	*gettty();
char	*getptr();
char	*strncmp();
int	aflg;
int	mem;
int	swmem;
int	swap;
daddr_t	swplo;

int	ndev;
struct devl {
	char	dname[DIRSIZ];
	dev_t	dev;
} devl[256];

char	*coref;

main(argc, argv)
char **argv;
{
	int i;
	char *ap;
	int uid, puid;

	if (argc>1) {
		ap = argv[1];
		while (*ap) switch (*ap++) {

		case 'v':
			vflg++;
			break;

		case 'a':
			aflg++;
			break;

		case 't':
			if(*ap)
				tptr = ap;
			aflg++;
			if (*tptr == '?')
				xflg++;
			goto bbreak;

		case 'x':
			xflg++;
			break;

		case '-':
			break;

		case 'l':
			lflg++;
			break;

		case 'k':
			kflg++;
			break;

		default:
			chkpid = atoi(ap-1);
			goto bbreak;
			break;
		}
	}

bbreak:
	if(chdir("/dev") < 0) {
		fprintf(stderr, "Can't change to /dev\n");
		exit(1);
	}
	nlist(argc>2? argv[2]:"/unix", nl);
	if (nl[0].n_type==0) {
		fprintf(stderr, "No namelist\n");
		exit(1);
	}
	coref = "/dev/mem";
	if(kflg)
		coref = "/usr/sys/core";
	if ((mem = open(coref, 0)) < 0) {
		fprintf(stderr, "No mem\n");
		exit(1);
	}
	swmem = open(coref, 0);
	/*
	 * read mem to find swap dev.
	 */
	lseek(mem, (long)nl[1].n_value, 0);
	read(mem, (char *)&nl[1].n_value, sizeof(nl[1].n_value));
	/*
	 * Find base of swap
	 */
	lseek(mem, (long)nl[2].n_value, 0);
	read(mem, (char *)&swplo, sizeof(swplo));
	/*
	 * Locate proc table
	 */
	lseek(mem, (long)nl[0].n_value, 0);
	getdev();
	uid = getuid();
	if (lflg)
	printf(" F S UID   PID  PPID CPU PRI NICE  ADDR  SZ  WCHAN TTY TIME CMD\n"); else
		if (chkpid==0) printf("   PID TTY TIME CMD\n");
	for (i=0; i<NPROC; i++) {
		read(mem, (char *)&mproc, sizeof mproc);
		if (mproc.p_stat==0)
			continue;
		if (mproc.p_pgrp==0 && xflg==0 && mproc.p_uid==0)
			continue;
		puid = mproc.p_uid;
		if ((uid != puid && aflg==0) ||
		    (chkpid!=0 && chkpid!=mproc.p_pid))
			continue;
		if(prcom(puid)) {
			printf("\n");
			retcode=0;
		}
	}
	exit(retcode);
}

getdev()
{
#include <sys/stat.h>
	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);
	if ((swap = open("/dev/swap", 0)) < 0) {
		fprintf(stderr, "Can't open /dev/swap\n");
		exit(1);
	}
}

long
round(a, b)
	long		a, b;
{
	long		w = ((a+b-1)/b)*b;

	return(w);
}

struct map {
	long	b1, e1; long f1;
	long	b2, e2; long f2;
};
struct map datmap;
int	file;
prcom(puid)
{
	char abuf[512];
	long addr;
	register int *ip;
	register char *cp, *cp1;
	long tm;
	int c, nbad;
	register char *tp;
	long txtsiz, datsiz, stksiz;
	int septxt;
	int lw=(lflg?35:80);
	char **ap;

	if (mproc.p_flag&SLOAD) {
		addr = ctob((long)mproc.p_addr);
		file = swmem;
	} else {
		addr = (mproc.p_addr+swplo)<<9;
		file = swap;
	}
	lseek(file, addr, 0);
	if (read(file, (char *)&u, sizeof(u)) != sizeof(u))
		return(0);

	/* set up address maps for user pcs */
	txtsiz = ctob(u.u_tsize);
	datsiz = ctob(u.u_dsize);
	stksiz = ctob(u.u_ssize);
	septxt = u.u_sep;
	datmap.b1 = (septxt ? 0 : round(txtsiz,TXTRNDSIZ));
	datmap.e1 = datmap.b1+datsiz;
	datmap.f1 = ctob(USIZE)+addr;
	datmap.b2 = stackbas(stksiz);
	datmap.e2 = stacktop(stksiz);
	datmap.f2 = ctob(USIZE)+(datmap.e1-datmap.b1)+addr;

	tp = gettty();
	if (tptr && strncmp(tptr, tp, 2))
		return(0);
	if (lflg) {
		printf("%2o %c%4d", mproc.p_flag,
			"0SWRIZT"[mproc.p_stat], puid);
	}
	printf("%6u", mproc.p_pid);
	if (lflg) {
		printf("%6u%4d%4d%5d%6o%4d", mproc.p_ppid, mproc.p_cpu&0377,
			mproc.p_pri,
			mproc.p_nice,
			mproc.p_addr, (mproc.p_size+7)>>3);
		if (mproc.p_wchan)
			printf("%7o", mproc.p_wchan);
		else
			printf("       ");
	}
	printf(" %-2.2s", tp);
	if (mproc.p_stat==SZOMB) {
		printf("  <defunct>");
		return(1);
	}
	tm = (u.u_utime + u.u_stime + 30)/60;
	printf(" %2ld:", tm/60);
	tm %= 60;
	printf(tm<10?"0%ld":"%ld", tm);
	if (vflg && lflg==0) {	/* 0 == old tflg (print long times) */
		tm = (u.u_cstime + 30)/60;
		printf(" %2ld:", tm/60);
		tm %= 60;
		printf(tm<10?"0%ld":"%ld", tm);
		tm = (u.u_cutime + 30)/60;
		printf(" %2ld:", tm/60);
		tm %= 60;
		printf(tm<10?"0%ld":"%ld", tm);
	}
	if (mproc.p_pid == 0) {
		printf(" swapper");
		return(1);
	}
	addr += ctob((long)mproc.p_size) - 512;

	/* look for sh special */
	lseek(file, addr+512-sizeof(char **), 0);
	if (read(file, (char *)&ap, sizeof(char *)) != sizeof(char *))
		return(1);
	if (ap) {
		char b[82];
		char *bp = b;
		while((cp=getptr(ap++)) && cp && (bp<b+lw) ) {
			nbad = 0;
			while((c=getbyte(cp++)) && (bp<b+lw)) {
				if (c<' ' || c>'~') {
					if (nbad++>3)
						break;
					continue;
				}
				*bp++ = c;
			}
			*bp++ = ' ';
		}
		*bp++ = 0;
		printf(lflg?" %.30s":" %.60s", b);
		return(1);
	}

	lseek(file, addr, 0);
	if (read(file, abuf, sizeof(abuf)) != sizeof(abuf))
		return(1);
	for (ip = (int *)&abuf[512]-2; ip > (int *)abuf; ) {
		if (*--ip == -1 || *ip==0) {
			cp = (char *)(ip+1);
			if (*cp==0)
				cp++;
			nbad = 0;
			for (cp1 = cp; cp1 < &abuf[512]; cp1++) {
				c = *cp1&0177;
				if (c==0)
					*cp1 = ' ';
				else if (c < ' ' || c > 0176) {
					if (++nbad >= 5) {
						*cp1++ = ' ';
						break;
					}
					*cp1 = '?';
				} else if (c=='=') {
					*cp1 = 0;
					while (cp1>cp && *--cp1!=' ')
						*cp1 = 0;
					break;
				}
			}
			while (*--cp1==' ')
				*cp1 = 0;
			printf(lflg?" %.30s":" %.60s", cp);
			return(1);
		}
	}
	return(1);
}

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("?");
}

char *
getptr(adr)
char **adr;
{
	char *ptr;
	register char *p, *pa;
	register i;

	ptr = 0;
	pa = (char *)adr;
	p = (char *)&ptr;
	for (i=0; i<sizeof(ptr); i++)
		*p++ = getbyte(pa++);
	return(ptr);
}

getbyte(adr)
char *adr;
{
	register struct map *amap = &datmap;
	char b;
	long saddr;

	if(!within(adr, amap->b1, amap->e1)) {
		if(within(adr, amap->b2, amap->e2)) {
			saddr = (unsigned)adr + amap->f2 - amap->b2;
		} else
			return(0);
	} else
		saddr = (unsigned)adr + amap->f1 - amap->b1;
	if(lseek(file, saddr, 0)==-1
		   || read(file, &b, 1)<1) {
		return(0);
	}
	return((unsigned)b);
}


within(adr,lbd,ubd)
char *adr;
long lbd, ubd;
{
	return((unsigned)adr>=lbd && (unsigned)adr<ubd);
}
Commit	Line	Data
b4e2e355 KT	1	/*
	2	* ps - process status
	3	* examine and print certain things about processes
	4	*/
	5
	6	#include <stdio.h>
	7	#include <a.out.h>
	8	#include <core.h>
	9	#include <sys/param.h>
	10	#include <sys/proc.h>
	11	#include <sys/tty.h>
	12	#include <sys/dir.h>
	13	#include <sys/user.h>
	14
	15	struct nlist nl[] = {
	16	{ "_proc" },
	17	{ "_swapdev" },
	18	{ "_swplo" },
	19	{ "" },
	20	};
	21
	22	struct proc mproc;
	23
	24	struct user u;
	25	int chkpid;
	26	int retcode=1;
	27	int lflg;
	28	int vflg;
	29	int kflg;
	30	int xflg;
	31	char *tptr;
	32	long lseek();
	33	char *gettty();
	34	char *getptr();
	35	char *strncmp();
	36	int aflg;
	37	int mem;
	38	int swmem;
	39	int swap;
	40	daddr_t swplo;
	41
	42	int ndev;
	43	struct devl {
	44	char dname[DIRSIZ];
	45	dev_t dev;
	46	} devl[256];
	47
	48	char *coref;
	49
	50	main(argc, argv)
	51	char **argv;
	52	{
	53	int i;
	54	char *ap;
	55	int uid, puid;
	56
	57	if (argc>1) {
	58	ap = argv[1];
	59	while (ap) switch (ap++) {
	60
	61	case 'v':
	62	vflg++;
	63	break;
	64
65	case 'a':
66	aflg++;
67	break;
68
69	case 't':
70	if(*ap)
71	tptr = ap;
72	aflg++;
73	if (*tptr == '?')
74	xflg++;
75	goto bbreak;
76
77	case 'x':
78	xflg++;
79	break;
80
81	case '-':
82	break;
83
84	case 'l':
85	lflg++;
86	break;
87
88	case 'k':
89	kflg++;
90	break;
91
92	default:
93	chkpid = atoi(ap-1);
94	goto bbreak;
95	break;
96	}
97	}
98
99	bbreak:
100	if(chdir("/dev") < 0) {
101	fprintf(stderr, "Can't change to /dev\n");
102	exit(1);
103	}
104	nlist(argc>2? argv[2]:"/unix", nl);
105	if (nl[0].n_type==0) {
106	fprintf(stderr, "No namelist\n");
107	exit(1);
108	}
109	coref = "/dev/mem";
110	if(kflg)
111	coref = "/usr/sys/core";
112	if ((mem = open(coref, 0)) < 0) {
113	fprintf(stderr, "No mem\n");
114	exit(1);
115	}
116	swmem = open(coref, 0);
117	/*
118	* read mem to find swap dev.
119	*/
120	lseek(mem, (long)nl[1].n_value, 0);
121	read(mem, (char *)&nl[1].n_value, sizeof(nl[1].n_value));
122	/*
123	* Find base of swap
124	*/
125	lseek(mem, (long)nl[2].n_value, 0);
126	read(mem, (char *)&swplo, sizeof(swplo));
127	/*
128	* Locate proc table
129	*/
130	lseek(mem, (long)nl[0].n_value, 0);
131	getdev();
132	uid = getuid();
133	if (lflg)
134	printf(" F S UID PID PPID CPU PRI NICE ADDR SZ WCHAN TTY TIME CMD\n"); else
135	if (chkpid==0) printf(" PID TTY TIME CMD\n");
136	for (i=0; i<NPROC; i++) {
137	read(mem, (char *)&mproc, sizeof mproc);
138	if (mproc.p_stat==0)
139	continue;
140	if (mproc.p_pgrp==0 && xflg==0 && mproc.p_uid==0)
141	continue;
142	puid = mproc.p_uid;
143	if ((uid != puid && aflg==0) \|\|
144	(chkpid!=0 && chkpid!=mproc.p_pid))
145	continue;
146	if(prcom(puid)) {
147	printf("\n");
148	retcode=0;
149	}
150	}
151	exit(retcode);
152	}
153
154	getdev()
155	{
156	#include <sys/stat.h>
157	register FILE *df;
158	struct stat sbuf;
159	struct direct dbuf;
160
161	if ((df = fopen("/dev", "r")) == NULL) {
162	fprintf(stderr, "Can't open /dev\n");
163	exit(1);
164	}
165	ndev = 0;
166	while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
167	if(dbuf.d_ino == 0)
168	continue;
169	if(stat(dbuf.d_name, &sbuf) < 0)
170	continue;
171	if ((sbuf.st_mode&S_IFMT) != S_IFCHR)
172	continue;
173	strcpy(devl[ndev].dname, dbuf.d_name);
174	devl[ndev].dev = sbuf.st_rdev;
175	ndev++;
176	}
177	fclose(df);
178	if ((swap = open("/dev/swap", 0)) < 0) {
179	fprintf(stderr, "Can't open /dev/swap\n");
180	exit(1);
181	}
182	}
183
184	long
185	round(a, b)
186	long a, b;
187	{
188	long w = ((a+b-1)/b)*b;
189
190	return(w);
191	}
192
193	struct map {
194	long b1, e1; long f1;
195	long b2, e2; long f2;
196	};
197	struct map datmap;
198	int file;
199	prcom(puid)
200	{
201	char abuf[512];
202	long addr;
203	register int *ip;
204	register char cp, cp1;
205	long tm;
206	int c, nbad;
207	register char *tp;
208	long txtsiz, datsiz, stksiz;
209	int septxt;
210	int lw=(lflg?35:80);
211	char **ap;
212
213	if (mproc.p_flag&SLOAD) {
214	addr = ctob((long)mproc.p_addr);
215	file = swmem;
216	} else {
217	addr = (mproc.p_addr+swplo)<<9;
218	file = swap;
219	}
220	lseek(file, addr, 0);
221	if (read(file, (char *)&u, sizeof(u)) != sizeof(u))
222	return(0);
223
224	/* set up address maps for user pcs */
225	txtsiz = ctob(u.u_tsize);
226	datsiz = ctob(u.u_dsize);
227	stksiz = ctob(u.u_ssize);
228	septxt = u.u_sep;
229	datmap.b1 = (septxt ? 0 : round(txtsiz,TXTRNDSIZ));
230	datmap.e1 = datmap.b1+datsiz;
231	datmap.f1 = ctob(USIZE)+addr;
232	datmap.b2 = stackbas(stksiz);
233	datmap.e2 = stacktop(stksiz);
234	datmap.f2 = ctob(USIZE)+(datmap.e1-datmap.b1)+addr;
235
236	tp = gettty();
237	if (tptr && strncmp(tptr, tp, 2))
238	return(0);
239	if (lflg) {
240	printf("%2o %c%4d", mproc.p_flag,
241	"0SWRIZT"[mproc.p_stat], puid);
242	}
243	printf("%6u", mproc.p_pid);
244	if (lflg) {
245	printf("%6u%4d%4d%5d%6o%4d", mproc.p_ppid, mproc.p_cpu&0377,
246	mproc.p_pri,
247	mproc.p_nice,
248	mproc.p_addr, (mproc.p_size+7)>>3);
249	if (mproc.p_wchan)
250	printf("%7o", mproc.p_wchan);
251	else
252	printf(" ");
253	}
254	printf(" %-2.2s", tp);
255	if (mproc.p_stat==SZOMB) {
256	printf(" <defunct>");
257	return(1);
258	}
259	tm = (u.u_utime + u.u_stime + 30)/60;
260	printf(" %2ld:", tm/60);
261	tm %= 60;
262	printf(tm<10?"0%ld":"%ld", tm);
263	if (vflg && lflg==0) { /* 0 == old tflg (print long times) */
264	tm = (u.u_cstime + 30)/60;
265	printf(" %2ld:", tm/60);
266	tm %= 60;
267	printf(tm<10?"0%ld":"%ld", tm);
268	tm = (u.u_cutime + 30)/60;
269	printf(" %2ld:", tm/60);
270	tm %= 60;
271	printf(tm<10?"0%ld":"%ld", tm);
272	}
273	if (mproc.p_pid == 0) {
274	printf(" swapper");
275	return(1);
276	}
277	addr += ctob((long)mproc.p_size) - 512;
278
279	/* look for sh special */
280	lseek(file, addr+512-sizeof(char **), 0);
281	if (read(file, (char )&ap, sizeof(char )) != sizeof(char *))
282	return(1);
283	if (ap) {
284	char b[82];
285	char *bp = b;
286	while((cp=getptr(ap++)) && cp && (bp<b+lw) ) {
287	nbad = 0;
288	while((c=getbyte(cp++)) && (bp<b+lw)) {
289	if (c<' ' \|\| c>'~') {
290	if (nbad++>3)
291	break;
292	continue;
293	}
294	*bp++ = c;
295	}
296	*bp++ = ' ';
297	}
298	*bp++ = 0;
299	printf(lflg?" %.30s":" %.60s", b);
300	return(1);
301	}
302
303	lseek(file, addr, 0);
304	if (read(file, abuf, sizeof(abuf)) != sizeof(abuf))
305	return(1);
306	for (ip = (int )&abuf[512]-2; ip > (int )abuf; ) {
307	if (--ip == -1 \|\| ip==0) {
308	cp = (char *)(ip+1);
309	if (*cp==0)
310	cp++;
311	nbad = 0;
312	for (cp1 = cp; cp1 < &abuf[512]; cp1++) {
313	c = *cp1&0177;
314	if (c==0)
315	*cp1 = ' ';
316	else if (c < ' ' \|\| c > 0176) {
317	if (++nbad >= 5) {
318	*cp1++ = ' ';
319	break;
320	}
321	*cp1 = '?';
322	} else if (c=='=') {
323	*cp1 = 0;
324	while (cp1>cp && *--cp1!=' ')
325	*cp1 = 0;
326	break;
327	}
328	}
329	while (*--cp1==' ')
330	*cp1 = 0;
331	printf(lflg?" %.30s":" %.60s", cp);
332	return(1);
333	}
334	}
335	return(1);
336	}
337
338	char *
339	gettty()
340	{
341	register i;
342	register char *p;
343
344	if (u.u_ttyp==0)
345	return("?");
346	for (i=0; i<ndev; i++) {
347	if (devl[i].dev == u.u_ttyd) {
348	p = devl[i].dname;
349	if (p[0]=='t' && p[1]=='t' && p[2]=='y')
350	p += 3;
351	return(p);
352	}
353	}
354	return("?");
355	}
356
357	char *
358	getptr(adr)
359	char **adr;
360	{
361	char *ptr;
362	register char p, pa;
363	register i;
364
365	ptr = 0;
366	pa = (char *)adr;
367	p = (char *)&ptr;
368	for (i=0; i<sizeof(ptr); i++)
369	*p++ = getbyte(pa++);
370	return(ptr);
371	}
372
373	getbyte(adr)
374	char *adr;
375	{
376	register struct map *amap = &datmap;
377	char b;
378	long saddr;
379
380	if(!within(adr, amap->b1, amap->e1)) {
381	if(within(adr, amap->b2, amap->e2)) {
382	saddr = (unsigned)adr + amap->f2 - amap->b2;
383	} else
384	return(0);
385	} else
386	saddr = (unsigned)adr + amap->f1 - amap->b1;
387	if(lseek(file, saddr, 0)==-1
388	\|\| read(file, &b, 1)<1) {
389	return(0);
390	}
391	return((unsigned)b);
392	}
393
394
395	within(adr,lbd,ubd)
396	char *adr;
397	long lbd, ubd;
398	{
399	return((unsigned)adr>=lbd && (unsigned)adr<ubd);
400	}