xref: /dragonfly/bin/ps/print.c (revision 23265324) 
1 /*-
2  * Copyright (c) 1990, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#)print.c	8.6 (Berkeley) 4/16/94
34  * $FreeBSD: src/bin/ps/print.c,v 1.36.2.4 2002/11/30 13:00:14 tjr Exp $
35  * $DragonFly: src/bin/ps/print.c,v 1.31 2007/02/18 16:15:23 corecode Exp $
36  */
37 
38 #include <sys/param.h>
39 #include <sys/time.h>
40 #include <sys/resource.h>
41 #include <sys/stat.h>
42 
43 #include <sys/ucred.h>
44 #include <sys/user.h>
45 #include <sys/sysctl.h>
46 #include <sys/rtprio.h>
47 #include <vm/vm.h>
48 
49 #include <err.h>
50 #include <langinfo.h>
51 #include <locale.h>
52 #include <math.h>
53 #include <nlist.h>
54 #include <stddef.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <unistd.h>
58 #include <string.h>
59 #include <vis.h>
60 
61 #include "ps.h"
62 
63 static const char *make_printable(const char *str);
64 
65 void
66 printheader(void)
67 {
68 	const VAR *v;
69 	struct varent *vent;
70 	int allempty;
71 
72 	allempty = 1;
73 	STAILQ_FOREACH(vent, &var_head, link) {
74 		if (*vent->header != '\0') {
75 			allempty = 0;
76 			break;
77 		}
78 	}
79 	if (allempty)
80 		return;
81 	STAILQ_FOREACH(vent, &var_head, link) {
82 		v = vent->var;
83 		if (v->flag & LJUST) {
84 			if (STAILQ_NEXT(vent, link) == NULL)	/* last one */
85 				printf("%s", vent->header);
86 			else
87 				printf("%-*s", vent->width, vent->header);
88 		} else
89 			printf("%*s", vent->width, vent->header);
90 		if (STAILQ_NEXT(vent, link) != NULL)
91 			putchar(' ');
92 	}
93 	putchar('\n');
94 }
95 
96 void
97 command(const KINFO *k, const struct varent *vent)
98 {
99 	const VAR *v;
100 	int left;
101 	char *cp, *vis_env, *vis_args;
102 
103 	v = vent->var;
104 
105 	if (cflag) {
106 		/* Don't pad the last field. */
107 		if (STAILQ_NEXT(vent, link) == NULL)
108 			printf("%s", make_printable(KI_PROC(k, comm)));
109 		else
110 			printf("%-*s", vent->width,
111 				make_printable(KI_PROC(k, comm)));
112 		return;
113 	}
114 
115 	if ((vis_args = malloc(strlen(k->ki_args) * 4 + 1)) == NULL)
116 		err(1, NULL);
117 	strvis(vis_args, k->ki_args, VIS_TAB | VIS_NL | VIS_NOSLASH);
118 	if (k->ki_env) {
119 		if ((vis_env = malloc(strlen(k->ki_env) * 4 + 1)) == NULL)
120 			err(1, NULL);
121 		strvis(vis_env, k->ki_env, VIS_TAB | VIS_NL | VIS_NOSLASH);
122 	} else
123 		vis_env = NULL;
124 
125 	if (STAILQ_NEXT(vent, link) == NULL) {
126 		/* last field */
127 		if (termwidth == UNLIMITED) {
128 			if (vis_env)
129 				printf("%s ", vis_env);
130 			printf("%s", vis_args);
131 		} else {
132 			left = termwidth - (totwidth - vent->width);
133 			if (left < 1) /* already wrapped, just use std width */
134 				left = vent->width;
135 			if ((cp = vis_env) != NULL) {
136 				while (--left >= 0 && *cp)
137 					putchar(*cp++);
138 				if (--left >= 0)
139 					putchar(' ');
140 			}
141 			for (cp = vis_args; --left >= 0 && *cp != '\0';)
142 				putchar(*cp++);
143 		}
144 	} else
145 		/* XXX env? */
146 		printf("%-*.*s", vent->width, vent->width, vis_args);
147 	free(vis_args);
148 	if (vis_env != NULL)
149 		free(vis_env);
150 }
151 
152 void
153 ucomm(const KINFO *k, const struct varent *vent)
154 {
155 	printf("%-*s", vent->width, make_printable(KI_PROC(k, comm)));
156 }
157 
158 void
159 logname(const KINFO *k, const struct varent *vent)
160 {
161 	const char *s = KI_PROC(k, login);
162 
163 	printf("%-*s", vent->width, *s != '\0' ? s : "-");
164 }
165 
166 void
167 state(const KINFO *k, const struct varent *vent)
168 {
169 	int flag;
170 	char *cp;
171 	char buf[16];
172 
173 	flag = KI_PROC(k, flags);
174 	cp = buf;
175 
176 	switch (KI_PROC(k, stat)) {
177 
178 	case SSTOP:
179 		*cp = 'T';
180 		break;
181 
182 	case SACTIVE:
183 		switch (KI_LWP(k, stat)) {
184 		case LSSLEEP:
185 			if (KI_LWP(k, flags) & LWP_SINTR)	/* interruptable (long) */
186 				*cp = KI_LWP(k, slptime) >= MAXSLP ? 'I' : 'S';
187 			else if (KI_LWP(k, tdflags) & TDF_SINTR)
188 				*cp = 'S';
189 			else
190 				*cp = 'D';
191 			break;
192 
193 		case LSRUN:
194 			*cp = 'R';
195 			if (KI_LWP(k, tdflags) & TDF_RUNNING) {
196 			    ++cp;
197 			    sprintf(cp, "%d", KI_LWP(k, cpuid));
198 			    while (cp[1])
199 				++cp;
200 			}
201 			break;
202 
203 		case LSSTOP:
204 			/* shouldn't happen anyways */
205 			*cp = 'T';
206 			break;
207 		}
208 		break;
209 
210 	case SZOMB:
211 		*cp = 'Z';
212 		break;
213 
214 	default:
215 		*cp = '?';
216 	}
217 
218 	cp++;
219 	if (flag & P_SWAPPEDOUT)
220 		*cp++ = 'W';
221 	if (KI_PROC(k, nice) < NZERO)
222 		*cp++ = '<';
223 	else if (KI_PROC(k, nice) > NZERO)
224 		*cp++ = 'N';
225 	if (flag & P_TRACED)
226 		*cp++ = 'X';
227 	if (flag & P_WEXIT && KI_PROC(k, stat) != SZOMB)
228 		*cp++ = 'E';
229 	if (flag & P_PPWAIT)
230 		*cp++ = 'V';
231 	if ((flag & P_SYSTEM) || KI_PROC(k, lock) > 0)
232 		*cp++ = 'L';
233 	if (numcpus > 1 && KI_LWP(k, mpcount) == 0)
234 		*cp++ = 'M';
235 	if (flag & P_JAILED)
236 		*cp++ = 'J';
237 	if (KI_PROC(k, auxflags) & KI_SLEADER)
238 		*cp++ = 's';
239 	if ((flag & P_CONTROLT) && KI_PROC(k, pgid) == KI_PROC(k, tpgid))
240 		*cp++ = '+';
241 	*cp = '\0';
242 	printf("%-*s", vent->width, buf);
243 }
244 
245 /*
246  * Normalized priority (lower is better).  For pure threads
247  * output a negated LWKT priority (so lower still means better).
248  *
249  * XXX bsd4 scheduler specific.
250  */
251 void
252 pri(const KINFO *k, const struct varent *vent)
253 {
254 	if (KI_LWP(k, pid) != -1)
255 	    printf("%*d", vent->width, KI_LWP(k, prio));
256 	else
257 	    printf("%*d", vent->width, -(KI_LWP(k, tdprio) & TDPRI_MASK));
258 }
259 
260 void
261 tdpri(const KINFO *k, const struct varent *vent)
262 {
263 	char buf[32];
264 	int val = KI_LWP(k, tdprio);
265 
266 	snprintf(buf, sizeof(buf), "%02d/%d", val & TDPRI_MASK, val / TDPRI_CRIT);
267 	printf("%*s", vent->width, buf);
268 }
269 
270 void
271 uname(const KINFO *k, const struct varent *vent)
272 {
273 	printf("%-*s", vent->width,
274 	       user_from_uid(KI_PROC(k, uid), 0));
275 }
276 
277 int
278 s_uname(const KINFO *k)
279 {
280 	return (strlen(user_from_uid(KI_PROC(k, uid), 0)));
281 }
282 
283 void
284 runame(const KINFO *k, const struct varent *vent)
285 {
286 	printf("%-*s", vent->width,
287 	       user_from_uid(KI_PROC(k, ruid), 0));
288 }
289 
290 int
291 s_runame(const KINFO *k)
292 {
293 	return (strlen(user_from_uid(KI_PROC(k, ruid), 0)));
294 }
295 
296 void
297 tdev(const KINFO *k, const struct varent *vent)
298 {
299 	dev_t dev;
300 	char buff[16];
301 
302 	dev = KI_PROC(k, tdev);
303 	if (dev == NODEV)
304 		printf("%*s", vent->width, "??");
305 	else {
306 		snprintf(buff, sizeof(buff), "%d/%d", major(dev), minor(dev));
307 		printf("%*s", vent->width, buff);
308 	}
309 }
310 
311 void
312 tname(const KINFO *k, const struct varent *vent)
313 {
314 	dev_t dev;
315 	const char *ttname;
316 
317 	dev = KI_PROC(k, tdev);
318 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
319 		printf("%*s ", vent->width-1, "??");
320 	else {
321 		if (strncmp(ttname, "tty", 3) == 0 ||
322 		    strncmp(ttname, "cua", 3) == 0)
323 			ttname += 3;
324 		printf("%*.*s%c", vent->width-1, vent->width-1, ttname,
325 			KI_PROC(k, auxflags) & KI_CTTY ? ' ' : '-');
326 	}
327 }
328 
329 void
330 longtname(const KINFO *k, const struct varent *vent)
331 {
332 	dev_t dev;
333 	const char *ttname;
334 
335 	dev = KI_PROC(k, tdev);
336 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
337 		printf("%-*s", vent->width, "??");
338 	else
339 		printf("%-*s", vent->width, ttname);
340 }
341 
342 void
343 started(const KINFO *k, const struct varent *vent)
344 {
345 	static time_t now;
346 	time_t then;
347 	struct tm *tp;
348 	char buf[100];
349 	static int  use_ampm = -1;
350 
351 	if (use_ampm < 0)
352 		use_ampm = (*nl_langinfo(T_FMT_AMPM) != '\0');
353 
354 	then = KI_PROC(k, start).tv_sec;
355 	if (then < btime.tv_sec) {
356 		then = btime.tv_sec;
357 	}
358 
359 	tp = localtime(&then);
360 	if (!now)
361 		time(&now);
362 	if (now - then < 24 * 3600) {
363 		strftime(buf, sizeof(buf) - 1,
364 		use_ampm ? "%l:%M%p" : "%k:%M  ", tp);
365 	} else if (now - then < 7 * 86400) {
366 		strftime(buf, sizeof(buf) - 1,
367 		use_ampm ? "%a%I%p" : "%a%H  ", tp);
368 	} else
369 		strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
370 	printf("%-*s", vent->width, buf);
371 }
372 
373 void
374 lstarted(const KINFO *k, const struct varent *vent)
375 {
376 	time_t then;
377 	char buf[100];
378 
379 	then = KI_PROC(k, start).tv_sec;
380 	strftime(buf, sizeof(buf) -1, "%c", localtime(&then));
381 	printf("%-*s", vent->width, buf);
382 }
383 
384 void
385 wchan(const KINFO *k, const struct varent *vent)
386 {
387 	if (KI_LWP(k, wchan)) {
388 		if (*KI_LWP(k, wmesg) != '\0')
389 			printf("%-*.*s", vent->width, vent->width,
390 			       KI_LWP(k, wmesg));
391 		else
392 			printf("%-*lx", vent->width,
393 			       (long)KI_LWP(k, wchan));
394 	} else
395 		printf("%-*s", vent->width, "-");
396 }
397 
398 #ifndef pgtok
399 #define pgtok(a)        (((a)*getpagesize())/1024)
400 #endif
401 
402 void
403 vsize(const KINFO *k, const struct varent *vent)
404 {
405 	printf("%*d", vent->width, (KI_PROC(k, vm_map_size)/1024));
406 }
407 
408 void
409 rssize(const KINFO *k, const struct varent *vent)
410 {
411 	/* XXX don't have info about shared */
412 	printf("%*lu", vent->width, (u_long)pgtok(KI_PROC(k, vm_rssize)));
413 }
414 
415 void
416 p_rssize(const KINFO *k, const struct varent *vent)	/* doesn't account for text */
417 {
418 	printf("%*ld", vent->width, (long)pgtok(KI_PROC(k, vm_rssize)));
419 }
420 
421 void
422 cputime(const KINFO *k, const struct varent *vent)
423 {
424 	long secs;
425 	long psecs;	/* "parts" of a second. first micro, then centi */
426 	u_int64_t timeus;
427 	char obuff[128];
428 	static char decimal_point = '\0';
429 
430 	if (decimal_point == '\0')
431 		decimal_point = localeconv()->decimal_point[0];
432 
433 	/*
434 	 * This counts time spent handling interrupts.  We could
435 	 * fix this, but it is not 100% trivial (and interrupt
436 	 * time fractions only work on the sparc anyway).	XXX
437 	 */
438 	timeus = KI_LWP(k, uticks) + KI_LWP(k, sticks) +
439 		KI_LWP(k, iticks);
440 	secs = timeus / 1000000;
441 	psecs = timeus % 1000000;
442 	if (sumrusage) {
443 		secs += KI_PROC(k, cru).ru_utime.tv_sec +
444 			KI_PROC(k, cru).ru_stime.tv_sec;
445 		psecs += KI_PROC(k, cru).ru_utime.tv_usec +
446 			KI_PROC(k, cru).ru_stime.tv_usec;
447 	}
448 	/*
449 	 * round and scale to 100's
450 	 */
451 	psecs = (psecs + 5000) / 10000;
452 	secs += psecs / 100;
453 	psecs = psecs % 100;
454 	snprintf(obuff, sizeof(obuff),
455 	    "%3ld:%02ld%c%02ld", secs/60, secs%60, decimal_point, psecs);
456 	printf("%*s", vent->width, obuff);
457 }
458 
459 double
460 getpcpu(const KINFO *k)
461 {
462 	static int failure;
463 
464 	if (!nlistread)
465 		failure = donlist();
466 	if (failure)
467 		return (0.0);
468 
469 #define	fxtofl(fixpt)	((double)(fixpt) / fscale)
470 
471 	/* XXX - I don't like this */
472 	if (KI_PROC(k, swtime) == 0 || (KI_PROC(k, flags) & P_SWAPPEDOUT))
473 		return (0.0);
474 	if (rawcpu)
475 		return (100.0 * fxtofl(KI_LWP(k, pctcpu)));
476 	return (100.0 * fxtofl(KI_LWP(k, pctcpu)) /
477 		(1.0 - exp(KI_PROC(k, swtime) * log(fxtofl(ccpu)))));
478 }
479 
480 void
481 pcpu(const KINFO *k, const struct varent *vent)
482 {
483 	printf("%*.1f", vent->width, getpcpu(k));
484 }
485 
486 void
487 pnice(const KINFO *k, const struct varent *vent)
488 {
489 	int niceval;
490 
491 	switch (KI_LWP(k, rtprio).type) {
492 	case RTP_PRIO_REALTIME:
493 		niceval = PRIO_MIN - 1 - RTP_PRIO_MAX + KI_LWP(k, rtprio).prio;
494 		break;
495 	case RTP_PRIO_IDLE:
496 		niceval = PRIO_MAX + 1 + KI_LWP(k, rtprio).prio;
497 		break;
498 	case RTP_PRIO_THREAD:
499 		niceval = PRIO_MIN - 1 - RTP_PRIO_MAX - KI_LWP(k, rtprio).prio;
500 		break;
501 	default:
502 		niceval = KI_PROC(k, nice) - NZERO;
503 		break;
504 	}
505 	printf("%*d", vent->width, niceval);
506 }
507 
508 
509 double
510 getpmem(const KINFO *k)
511 {
512 	static int failure;
513 	double fracmem;
514 	int szptudot;
515 
516 	if (!nlistread)
517 		failure = donlist();
518 	if (failure)
519 		return (0.0);
520 
521 	if (KI_PROC(k, flags) & P_SWAPPEDOUT)
522 		return (0.0);
523 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
524 	szptudot = UPAGES;
525 	/* XXX don't have info about shared */
526 	fracmem = ((float)KI_PROC(k, vm_rssize) + szptudot)/mempages;
527 	return (100.0 * fracmem);
528 }
529 
530 void
531 pmem(const KINFO *k, const struct varent *vent)
532 {
533 	printf("%*.1f", vent->width, getpmem(k));
534 }
535 
536 void
537 pagein(const KINFO *k, const struct varent *vent)
538 {
539 	printf("%*ld", vent->width, KI_LWP(k, ru).ru_majflt);
540 }
541 
542 /* ARGSUSED */
543 void
544 maxrss(const KINFO *k __unused, const struct varent *vent)
545 {
546 	printf("%*ld", vent->width, KI_PROC(k, ru).ru_maxrss);
547 }
548 
549 void
550 tsize(const KINFO *k, const struct varent *vent)
551 {
552 	printf("%*ld", vent->width, (long)pgtok(KI_PROC(k, vm_tsize)));
553 }
554 
555 void
556 rtprior(const KINFO *k, const struct varent *vent)
557 {
558 	struct rtprio *prtp;
559 	char str[8];
560 	unsigned prio, type;
561 
562 	prtp = &KI_LWP(k, rtprio);
563 	prio = prtp->prio;
564 	type = prtp->type;
565 	switch (type) {
566 	case RTP_PRIO_REALTIME:
567 		snprintf(str, sizeof(str), "real:%u", prio);
568 		break;
569 	case RTP_PRIO_NORMAL:
570 		strncpy(str, "normal", sizeof(str));
571 		break;
572 	case RTP_PRIO_IDLE:
573 		snprintf(str, sizeof(str), "idle:%u", prio);
574 		break;
575 	default:
576 		snprintf(str, sizeof(str), "%u:%u", type, prio);
577 		break;
578 	}
579 	str[sizeof(str) - 1] = '\0';
580 	printf("%*s", vent->width, str);
581 }
582 
583 /*
584  * Generic output routines.  Print fields from various prototype
585  * structures.
586  */
587 static void
588 printval(const char *bp, const struct varent *vent)
589 {
590 	static char ofmt[32] = "%";
591 	const char *fcp;
592 	char *cp;
593 
594 	cp = ofmt + 1;
595 	fcp = vent->var->fmt;
596 	if (vent->var->flag & LJUST)
597 		*cp++ = '-';
598 	*cp++ = '*';
599 	while ((*cp++ = *fcp++));
600 
601 	switch (vent->var->type) {
602 	case CHAR:
603 		printf(ofmt, vent->width, *(const char *)bp);
604 		break;
605 	case UCHAR:
606 		printf(ofmt, vent->width, *(const u_char *)bp);
607 		break;
608 	case SHORT:
609 		printf(ofmt, vent->width, *(const short *)bp);
610 		break;
611 	case USHORT:
612 		printf(ofmt, vent->width, *(const u_short *)bp);
613 		break;
614 	case INT:
615 		printf(ofmt, vent->width, *(const int *)bp);
616 		break;
617 	case UINT:
618 		printf(ofmt, vent->width, *(const u_int *)bp);
619 		break;
620 	case LONG:
621 		printf(ofmt, vent->width, *(const long *)bp);
622 		break;
623 	case ULONG:
624 		printf(ofmt, vent->width, *(const u_long *)bp);
625 		break;
626 	case KPTR:
627 		printf(ofmt, vent->width, *(const u_long *)bp);
628 		break;
629 	default:
630 		errx(1, "unknown type %d", vent->var->type);
631 	}
632 }
633 
634 void
635 pvar(const KINFO *k, const struct varent *vent)
636 {
637 	printval((char *)((char *)k->ki_proc + vent->var->off), vent);
638 }
639 
640 void
641 lpest(const KINFO *k, const struct varent *vent)
642 {
643 	int val;
644 
645 	val = *(int *)((char *)&k->ki_proc->kp_lwp + vent->var->off);
646 	val = val / 128;
647 	printval((char *)&val, vent);
648 }
649 
650 
651 void
652 lpvar(const KINFO *k, const struct varent *vent)
653 {
654 	printval((char *)((char *)&k->ki_proc->kp_lwp + vent->var->off), vent);
655 }
656 
657 void
658 rvar(const KINFO *k, const struct varent *vent)
659 {
660 	printval(((const char *)&KI_LWP(k, ru) + vent->var->off), vent);
661 }
662 
663 static const char *
664 make_printable(const char *str)
665 {
666     static char *cpy;
667     int len;
668 
669     if (cpy)
670 	free(cpy);
671     len = strlen(str);
672     if ((cpy = malloc(len * 4 + 1)) == NULL)
673 	err(1, NULL);
674     strvis(cpy, str, VIS_TAB | VIS_NL | VIS_NOSLASH);
675     return(cpy);
676 }
677