xref: /dragonfly/bin/ps/print.c (revision 15b85273) 
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.34 2008/11/10 14:56:33 swildner 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) {
186 				/* interruptable wait short/long */
187 				*cp = KI_LWP(k, slptime) >= MAXSLP ? 'I' : 'S';
188 			}
189 			else if (KI_LWP(k, tdflags) & TDF_SINTR)
190 				*cp = 'S';	/* interruptable lwkt wait */
191 			else if (KI_PROC(k, paddr))
192 				*cp = 'D';	/* uninterruptable wait */
193 			else
194 				*cp = 'B';	/* uninterruptable lwkt wait */
195 			break;
196 
197 		case LSRUN:
198 			*cp = 'R';
199 			if (KI_LWP(k, tdflags) & TDF_RUNNING) {
200 			    ++cp;
201 			    sprintf(cp, "%d", KI_LWP(k, cpuid));
202 			    while (cp[1])
203 				++cp;
204 			}
205 			break;
206 
207 		case LSSTOP:
208 			/* shouldn't happen anyways */
209 			*cp = 'T';
210 			break;
211 		}
212 		break;
213 
214 	case SZOMB:
215 		*cp = 'Z';
216 		break;
217 
218 	default:
219 		*cp = '?';
220 	}
221 
222 	cp++;
223 	if (flag & P_SWAPPEDOUT)
224 		*cp++ = 'W';
225 	if (KI_PROC(k, nice) < NZERO)
226 		*cp++ = '<';
227 	else if (KI_PROC(k, nice) > NZERO)
228 		*cp++ = 'N';
229 	if (flag & P_TRACED)
230 		*cp++ = 'X';
231 	if (flag & P_WEXIT && KI_PROC(k, stat) != SZOMB)
232 		*cp++ = 'E';
233 	if (flag & P_PPWAIT)
234 		*cp++ = 'V';
235 	if ((flag & P_SYSTEM) || KI_PROC(k, lock) > 0)
236 		*cp++ = 'L';
237 	if (numcpus > 1 && KI_LWP(k, mpcount) == 0)
238 		*cp++ = 'M';
239 	if (flag & P_JAILED)
240 		*cp++ = 'J';
241 	if (KI_PROC(k, auxflags) & KI_SLEADER)
242 		*cp++ = 's';
243 	if ((flag & P_CONTROLT) && KI_PROC(k, pgid) == KI_PROC(k, tpgid))
244 		*cp++ = '+';
245 	*cp = '\0';
246 	printf("%-*s", vent->width, buf);
247 }
248 
249 /*
250  * Normalized priority (lower is better).  For pure threads
251  * output a negated LWKT priority (so lower still means better).
252  *
253  * XXX bsd4 scheduler specific.
254  */
255 void
256 pri(const KINFO *k, const struct varent *vent)
257 {
258 	if (KI_LWP(k, pid) != -1)
259 	    printf("%*d", vent->width, KI_LWP(k, prio));
260 	else
261 	    printf("%*d", vent->width, -(KI_LWP(k, tdprio) & TDPRI_MASK));
262 }
263 
264 void
265 tdpri(const KINFO *k, const struct varent *vent)
266 {
267 	char buf[32];
268 	int val = KI_LWP(k, tdprio);
269 
270 	snprintf(buf, sizeof(buf), "%02d/%d", val & TDPRI_MASK, val / TDPRI_CRIT);
271 	printf("%*s", vent->width, buf);
272 }
273 
274 void
275 uname(const KINFO *k, const struct varent *vent)
276 {
277 	printf("%-*s", vent->width,
278 	       user_from_uid(KI_PROC(k, uid), 0));
279 }
280 
281 int
282 s_uname(const KINFO *k)
283 {
284 	return (strlen(user_from_uid(KI_PROC(k, uid), 0)));
285 }
286 
287 void
288 runame(const KINFO *k, const struct varent *vent)
289 {
290 	printf("%-*s", vent->width,
291 	       user_from_uid(KI_PROC(k, ruid), 0));
292 }
293 
294 int
295 s_runame(const KINFO *k)
296 {
297 	return (strlen(user_from_uid(KI_PROC(k, ruid), 0)));
298 }
299 
300 void
301 tdev(const KINFO *k, const struct varent *vent)
302 {
303 	dev_t dev;
304 	char buff[16];
305 
306 	dev = KI_PROC(k, tdev);
307 	if (dev == NODEV)
308 		printf("%*s", vent->width, "??");
309 	else {
310 		snprintf(buff, sizeof(buff), "%d/%d", major(dev), minor(dev));
311 		printf("%*s", vent->width, buff);
312 	}
313 }
314 
315 void
316 tname(const KINFO *k, const struct varent *vent)
317 {
318 	dev_t dev;
319 	const char *ttname;
320 
321 	dev = KI_PROC(k, tdev);
322 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
323 		printf("%*s ", vent->width-1, "??");
324 	else {
325 		if (strncmp(ttname, "tty", 3) == 0 ||
326 		    strncmp(ttname, "cua", 3) == 0)
327 			ttname += 3;
328 		printf("%*.*s%c", vent->width-1, vent->width-1, ttname,
329 			KI_PROC(k, auxflags) & KI_CTTY ? ' ' : '-');
330 	}
331 }
332 
333 void
334 longtname(const KINFO *k, const struct varent *vent)
335 {
336 	dev_t dev;
337 	const char *ttname;
338 
339 	dev = KI_PROC(k, tdev);
340 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
341 		printf("%-*s", vent->width, "??");
342 	else
343 		printf("%-*s", vent->width, ttname);
344 }
345 
346 void
347 started(const KINFO *k, const struct varent *vent)
348 {
349 	static time_t now;
350 	time_t then;
351 	struct tm *tp;
352 	char buf[100];
353 	static int  use_ampm = -1;
354 
355 	if (use_ampm < 0)
356 		use_ampm = (*nl_langinfo(T_FMT_AMPM) != '\0');
357 
358 	then = KI_PROC(k, start).tv_sec;
359 	if (then < btime.tv_sec) {
360 		then = btime.tv_sec;
361 	}
362 
363 	tp = localtime(&then);
364 	if (!now)
365 		time(&now);
366 	if (now - then < 24 * 3600) {
367 		strftime(buf, sizeof(buf) - 1,
368 		use_ampm ? "%l:%M%p" : "%k:%M  ", tp);
369 	} else if (now - then < 7 * 86400) {
370 		strftime(buf, sizeof(buf) - 1,
371 		use_ampm ? "%a%I%p" : "%a%H  ", tp);
372 	} else
373 		strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
374 	printf("%-*s", vent->width, buf);
375 }
376 
377 void
378 lstarted(const KINFO *k, const struct varent *vent)
379 {
380 	time_t then;
381 	char buf[100];
382 
383 	then = KI_PROC(k, start).tv_sec;
384 	strftime(buf, sizeof(buf) -1, "%c", localtime(&then));
385 	printf("%-*s", vent->width, buf);
386 }
387 
388 void
389 wchan(const KINFO *k, const struct varent *vent)
390 {
391 	if (*KI_LWP(k, wmesg)) {
392 		printf("%-*.*s", vent->width, vent->width,
393 		       KI_LWP(k, wmesg));
394 	} else {
395 		printf("%-*s", vent->width, "-");
396 	}
397 }
398 
399 #ifndef pgtok
400 #define pgtok(a)        (((a)*getpagesize())/1024)
401 #endif
402 
403 void
404 vsize(const KINFO *k, const struct varent *vent)
405 {
406 	printf("%*ju", vent->width, (uintmax_t)(KI_PROC(k, vm_map_size)/1024));
407 }
408 
409 void
410 rssize(const KINFO *k, const struct varent *vent)
411 {
412 	/* XXX don't have info about shared */
413 	printf("%*lu", vent->width, (u_long)pgtok(KI_PROC(k, vm_rssize)));
414 }
415 
416 void
417 p_rssize(const KINFO *k, const struct varent *vent)	/* doesn't account for text */
418 {
419 	printf("%*ld", vent->width, (long)pgtok(KI_PROC(k, vm_rssize)));
420 }
421 
422 void
423 cputime(const KINFO *k, const struct varent *vent)
424 {
425 	long secs;
426 	long psecs;	/* "parts" of a second. first micro, then centi */
427 	u_int64_t timeus;
428 	char obuff[128];
429 	static char decimal_point = '\0';
430 
431 	if (decimal_point == '\0')
432 		decimal_point = localeconv()->decimal_point[0];
433 
434 	/*
435 	 * This counts time spent handling interrupts.  We could
436 	 * fix this, but it is not 100% trivial (and interrupt
437 	 * time fractions only work on the sparc anyway).	XXX
438 	 */
439 	timeus = KI_LWP(k, uticks) + KI_LWP(k, sticks) +
440 		KI_LWP(k, iticks);
441 	secs = timeus / 1000000;
442 	psecs = timeus % 1000000;
443 	if (sumrusage) {
444 		secs += KI_PROC(k, cru).ru_utime.tv_sec +
445 			KI_PROC(k, cru).ru_stime.tv_sec;
446 		psecs += KI_PROC(k, cru).ru_utime.tv_usec +
447 			KI_PROC(k, cru).ru_stime.tv_usec;
448 	}
449 	/*
450 	 * round and scale to 100's
451 	 */
452 	psecs = (psecs + 5000) / 10000;
453 	secs += psecs / 100;
454 	psecs = psecs % 100;
455 	snprintf(obuff, sizeof(obuff),
456 	    "%3ld:%02ld%c%02ld", secs/60, secs%60, decimal_point, psecs);
457 	printf("%*s", vent->width, obuff);
458 }
459 
460 double
461 getpcpu(const KINFO *k)
462 {
463 	static int failure;
464 
465 	if (!nlistread)
466 		failure = donlist();
467 	if (failure)
468 		return (0.0);
469 
470 #define	fxtofl(fixpt)	((double)(fixpt) / fscale)
471 
472 	/* XXX - I don't like this */
473 	if (KI_PROC(k, swtime) == 0 || (KI_PROC(k, flags) & P_SWAPPEDOUT))
474 		return (0.0);
475 	if (rawcpu)
476 		return (100.0 * fxtofl(KI_LWP(k, pctcpu)));
477 	return (100.0 * fxtofl(KI_LWP(k, pctcpu)) /
478 		(1.0 - exp(KI_PROC(k, swtime) * log(fxtofl(ccpu)))));
479 }
480 
481 void
482 pcpu(const KINFO *k, const struct varent *vent)
483 {
484 	printf("%*.1f", vent->width, getpcpu(k));
485 }
486 
487 void
488 pnice(const KINFO *k, const struct varent *vent)
489 {
490 	int niceval;
491 
492 	switch (KI_LWP(k, rtprio).type) {
493 	case RTP_PRIO_REALTIME:
494 		niceval = PRIO_MIN - 1 - RTP_PRIO_MAX + KI_LWP(k, rtprio).prio;
495 		break;
496 	case RTP_PRIO_IDLE:
497 		niceval = PRIO_MAX + 1 + KI_LWP(k, rtprio).prio;
498 		break;
499 	case RTP_PRIO_THREAD:
500 		niceval = PRIO_MIN - 1 - RTP_PRIO_MAX - KI_LWP(k, rtprio).prio;
501 		break;
502 	default:
503 		niceval = KI_PROC(k, nice) - NZERO;
504 		break;
505 	}
506 	printf("%*d", vent->width, niceval);
507 }
508 
509 
510 double
511 getpmem(const KINFO *k)
512 {
513 	static int failure;
514 	double fracmem;
515 	int szptudot;
516 
517 	if (!nlistread)
518 		failure = donlist();
519 	if (failure)
520 		return (0.0);
521 
522 	if (KI_PROC(k, flags) & P_SWAPPEDOUT)
523 		return (0.0);
524 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
525 	szptudot = UPAGES;
526 	/* XXX don't have info about shared */
527 	fracmem = ((float)KI_PROC(k, vm_rssize) + szptudot)/mempages;
528 	return (100.0 * fracmem);
529 }
530 
531 void
532 pmem(const KINFO *k, const struct varent *vent)
533 {
534 	printf("%*.1f", vent->width, getpmem(k));
535 }
536 
537 void
538 pagein(const KINFO *k, const struct varent *vent)
539 {
540 	printf("%*ld", vent->width, KI_LWP(k, ru).ru_majflt);
541 }
542 
543 /* ARGSUSED */
544 void
545 maxrss(const KINFO *k __unused, const struct varent *vent)
546 {
547 	printf("%*ld", vent->width, KI_PROC(k, ru).ru_maxrss);
548 }
549 
550 void
551 tsize(const KINFO *k, const struct varent *vent)
552 {
553 	printf("%*ld", vent->width, (long)pgtok(KI_PROC(k, vm_tsize)));
554 }
555 
556 void
557 rtprior(const KINFO *k, const struct varent *vent)
558 {
559 	struct rtprio *prtp;
560 	char str[8];
561 	unsigned prio, type;
562 
563 	prtp = &KI_LWP(k, rtprio);
564 	prio = prtp->prio;
565 	type = prtp->type;
566 	switch (type) {
567 	case RTP_PRIO_REALTIME:
568 		snprintf(str, sizeof(str), "real:%u", prio);
569 		break;
570 	case RTP_PRIO_NORMAL:
571 		strncpy(str, "normal", sizeof(str));
572 		break;
573 	case RTP_PRIO_IDLE:
574 		snprintf(str, sizeof(str), "idle:%u", prio);
575 		break;
576 	default:
577 		snprintf(str, sizeof(str), "%u:%u", type, prio);
578 		break;
579 	}
580 	str[sizeof(str) - 1] = '\0';
581 	printf("%*s", vent->width, str);
582 }
583 
584 /*
585  * Generic output routines.  Print fields from various prototype
586  * structures.
587  */
588 static void
589 printval(const char *bp, const struct varent *vent)
590 {
591 	static char ofmt[32] = "%";
592 	const char *fcp;
593 	char *cp;
594 
595 	cp = ofmt + 1;
596 	fcp = vent->var->fmt;
597 	if (vent->var->flag & LJUST)
598 		*cp++ = '-';
599 	*cp++ = '*';
600 	while ((*cp++ = *fcp++));
601 
602 	switch (vent->var->type) {
603 	case CHAR:
604 		printf(ofmt, vent->width, *(const char *)bp);
605 		break;
606 	case UCHAR:
607 		printf(ofmt, vent->width, *(const u_char *)bp);
608 		break;
609 	case SHORT:
610 		printf(ofmt, vent->width, *(const short *)bp);
611 		break;
612 	case USHORT:
613 		printf(ofmt, vent->width, *(const u_short *)bp);
614 		break;
615 	case INT:
616 		printf(ofmt, vent->width, *(const int *)bp);
617 		break;
618 	case UINT:
619 		printf(ofmt, vent->width, *(const u_int *)bp);
620 		break;
621 	case LONG:
622 		printf(ofmt, vent->width, *(const long *)bp);
623 		break;
624 	case ULONG:
625 		printf(ofmt, vent->width, *(const u_long *)bp);
626 		break;
627 	case KPTR:
628 		printf(ofmt, vent->width, *(const u_long *)bp);
629 		break;
630 	default:
631 		errx(1, "unknown type %d", vent->var->type);
632 	}
633 }
634 
635 void
636 pvar(const KINFO *k, const struct varent *vent)
637 {
638 	printval((char *)((char *)k->ki_proc + vent->var->off), vent);
639 }
640 
641 void
642 lpest(const KINFO *k, const struct varent *vent)
643 {
644 	int val;
645 
646 	val = *(int *)((char *)&k->ki_proc->kp_lwp + vent->var->off);
647 	val = val / 128;
648 	printval((char *)&val, vent);
649 }
650 
651 
652 void
653 lpvar(const KINFO *k, const struct varent *vent)
654 {
655 	printval((char *)((char *)&k->ki_proc->kp_lwp + vent->var->off), vent);
656 }
657 
658 void
659 rvar(const KINFO *k, const struct varent *vent)
660 {
661 	printval(((const char *)&KI_LWP(k, ru) + vent->var->off), vent);
662 }
663 
664 static const char *
665 make_printable(const char *str)
666 {
667     static char *cpy;
668     int len;
669 
670     if (cpy)
671 	free(cpy);
672     len = strlen(str);
673     if ((cpy = malloc(len * 4 + 1)) == NULL)
674 	err(1, NULL);
675     strvis(cpy, str, VIS_TAB | VIS_NL | VIS_NOSLASH);
676     return(cpy);
677 }
678