xref: /netbsd-src/bin/ps/print.c (revision 404fbe5fb94ca1e054339640cabb2801ce52dd30)
1 /*	$NetBSD: print.c,v 1.107 2008/12/28 19:50:22 christos Exp $	*/
2 
3 /*
4  * Copyright (c) 2000, 2007 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Simon Burge.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /*
33  * Copyright (c) 1990, 1993, 1994
34  *	The Regents of the University of California.  All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  * 1. Redistributions of source code must retain the above copyright
40  *    notice, this list of conditions and the following disclaimer.
41  * 2. Redistributions in binary form must reproduce the above copyright
42  *    notice, this list of conditions and the following disclaimer in the
43  *    documentation and/or other materials provided with the distribution.
44  * 3. Neither the name of the University nor the names of its contributors
45  *    may be used to endorse or promote products derived from this software
46  *    without specific prior written permission.
47  *
48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58  * SUCH DAMAGE.
59  */
60 
61 #include <sys/cdefs.h>
62 #ifndef lint
63 #if 0
64 static char sccsid[] = "@(#)print.c	8.6 (Berkeley) 4/16/94";
65 #else
66 __RCSID("$NetBSD: print.c,v 1.107 2008/12/28 19:50:22 christos Exp $");
67 #endif
68 #endif /* not lint */
69 
70 #include <sys/param.h>
71 #include <sys/time.h>
72 #include <sys/resource.h>
73 #include <sys/lwp.h>
74 #include <sys/proc.h>
75 #include <sys/stat.h>
76 #include <sys/ucred.h>
77 #include <sys/sysctl.h>
78 
79 #include <err.h>
80 #include <grp.h>
81 #include <kvm.h>
82 #include <math.h>
83 #include <nlist.h>
84 #include <pwd.h>
85 #include <stddef.h>
86 #include <stdio.h>
87 #include <stdlib.h>
88 #include <string.h>
89 #include <time.h>
90 #include <tzfile.h>
91 #include <unistd.h>
92 
93 #include "ps.h"
94 
95 static char *cmdpart(char *);
96 static void  printval(void *, VAR *, int);
97 static int   titlecmp(char *, char **);
98 
99 static void  doubleprintorsetwidth(VAR *, double, int, int);
100 static void  intprintorsetwidth(VAR *, int, int);
101 static void  strprintorsetwidth(VAR *, const char *, int);
102 
103 static time_t now;
104 static int ncpu;
105 static u_int64_t *cp_id;
106 
107 #define	min(a,b)	((a) <= (b) ? (a) : (b))
108 
109 static int
110 iwidth(u_int64_t v)
111 {
112 	u_int64_t nlim, lim;
113 	int w = 1;
114 
115 	for (lim = 10; v >= lim; lim = nlim) {
116 		nlim = lim * 10;
117 		w++;
118 		if (nlim < lim)
119 			break;
120 	}
121 	return w;
122 }
123 
124 static char *
125 cmdpart(char *arg0)
126 {
127 	char *cp;
128 
129 	return ((cp = strrchr(arg0, '/')) != NULL ? cp + 1 : arg0);
130 }
131 
132 void
133 printheader(void)
134 {
135 	int len;
136 	VAR *v;
137 	struct varent *vent;
138 	static int firsttime = 1;
139 	static int noheader = 0;
140 
141 	/*
142 	 * If all the columns have user-specified null headers,
143 	 * don't print the blank header line at all.
144 	 */
145 	if (firsttime) {
146 		SIMPLEQ_FOREACH(vent, &displaylist, next) {
147 			if (vent->var->header[0])
148 				break;
149 		}
150 		if (vent == NULL) {
151 			noheader = 1;
152 			firsttime = 0;
153 		}
154 
155 	}
156 	if (noheader)
157 		return;
158 
159 	SIMPLEQ_FOREACH(vent, &displaylist, next) {
160 		v = vent->var;
161 		if (firsttime) {
162 			len = strlen(v->header);
163 			if (len > v->width)
164 				v->width = len;
165 			totwidth += v->width + 1;	/* +1 for space */
166 		}
167 		if (v->flag & LJUST) {
168 			if (SIMPLEQ_NEXT(vent, next) == NULL)	/* last one */
169 				(void)printf("%s", v->header);
170 			else
171 				(void)printf("%-*s", v->width,
172 				    v->header);
173 		} else
174 			(void)printf("%*s", v->width, v->header);
175 		if (SIMPLEQ_NEXT(vent, next) != NULL)
176 			(void)putchar(' ');
177 	}
178 	(void)putchar('\n');
179 	if (firsttime) {
180 		firsttime = 0;
181 		totwidth--;	/* take off last space */
182 	}
183 }
184 
185 /*
186  * Return 1 if the command name in the argument vector (u-area) does
187  * not match the command name (p_comm)
188  */
189 static int
190 titlecmp(char *name, char **argv)
191 {
192 	char *title;
193 	int namelen;
194 
195 
196 	/* no argument vector == no match; system processes/threads do that */
197 	if (argv == 0 || argv[0] == 0)
198 		return (1);
199 
200 	title = cmdpart(argv[0]);
201 
202 	/* the basename matches */
203 	if (!strcmp(name, title))
204 		return (0);
205 
206 	/* handle login shells, by skipping the leading - */
207 	if (title[0] == '-' && !strcmp(name, title + 1))
208 		return (0);
209 
210 	namelen = strlen(name);
211 
212 	/* handle daemons that report activity as daemonname: activity */
213 	if (argv[1] == 0 &&
214 	    !strncmp(name, title, namelen) &&
215 	    title[namelen + 0] == ':' &&
216 	    title[namelen + 1] == ' ')
217 		return (0);
218 
219 	return (1);
220 }
221 
222 static void
223 doubleprintorsetwidth(VAR *v, double val, int prec, int mode)
224 {
225 	int fmtlen;
226 
227 	if (mode == WIDTHMODE) {
228 		if (val < 0.0 && val < v->longestnd) {
229 			fmtlen = (int)log10(-val) + prec + 2;
230 			v->longestnd = val;
231 			if (fmtlen > v->width)
232 				v->width = fmtlen;
233 		} else if (val > 0.0 && val > v->longestpd) {
234 			fmtlen = (int)log10(val) + prec + 1;
235 			v->longestpd = val;
236 			if (fmtlen > v->width)
237 				v->width = fmtlen;
238 		}
239 	} else {
240 		(void)printf("%*.*f", v->width, prec, val);
241 	}
242 }
243 
244 static void
245 intprintorsetwidth(VAR *v, int val, int mode)
246 {
247 	int fmtlen;
248 
249 	if (mode == WIDTHMODE) {
250 		if (val < 0 && val < v->longestn) {
251 			v->longestn = val;
252 			fmtlen = iwidth(-val) + 1;
253 			if (fmtlen > v->width)
254 				v->width = fmtlen;
255 		} else if (val > 0 && val > v->longestp) {
256 			v->longestp = val;
257 			fmtlen = iwidth(val);
258 			if (fmtlen > v->width)
259 				v->width = fmtlen;
260 		}
261 	} else
262 		(void)printf("%*d", v->width, val);
263 }
264 
265 static void
266 strprintorsetwidth(VAR *v, const char *str, int mode)
267 {
268 	int len;
269 
270 	if (mode == WIDTHMODE) {
271 		len = strlen(str);
272 		if (len > v->width)
273 			v->width = len;
274 	} else {
275 		if (v->flag & LJUST)
276 			(void)printf("%-*.*s", v->width, v->width, str);
277 		else
278 			(void)printf("%*.*s", v->width, v->width, str);
279 	}
280 }
281 
282 void
283 command(void *arg, VARENT *ve, int mode)
284 {
285 	struct kinfo_proc2 *ki;
286 	VAR *v;
287 	int left;
288 	char **argv, **p, *name;
289 
290 	if (mode == WIDTHMODE)
291 		return;
292 
293 	ki = arg;
294 	v = ve->var;
295 	if (SIMPLEQ_NEXT(ve, next) != NULL || termwidth != UNLIMITED) {
296 		if (SIMPLEQ_NEXT(ve, next) == NULL) {
297 			left = termwidth - (totwidth - v->width);
298 			if (left < 1) /* already wrapped, just use std width */
299 				left = v->width;
300 		} else
301 			left = v->width;
302 	} else
303 		left = -1;
304 	if (needenv && kd) {
305 		argv = kvm_getenvv2(kd, ki, termwidth);
306 		if ((p = argv) != NULL) {
307 			while (*p) {
308 				fmt_puts(*p, &left);
309 				p++;
310 				fmt_putc(' ', &left);
311 			}
312 		}
313 	}
314 	if (needcomm) {
315 		name = ki->p_comm;
316 		if (!commandonly) {
317 			argv = kvm_getargv2(kd, ki, termwidth);
318 			if ((p = argv) != NULL) {
319 				while (*p) {
320 					fmt_puts(*p, &left);
321 					p++;
322 					fmt_putc(' ', &left);
323 					if (v->flag & ARGV0)
324 						break;
325 				}
326 				if (!(v->flag & ARGV0) &&
327 				    titlecmp(name, argv)) {
328 					/*
329 					 * append the real command name within
330 					 * parentheses, if the command name
331 					 * does not match the one in the
332 					 * argument vector
333 					 */
334 					fmt_putc('(', &left);
335 					fmt_puts(name, &left);
336 					fmt_putc(')', &left);
337 				}
338 			} else {
339 				/*
340 				 * Commands that don't set an argv vector
341 				 * are printed with square brackets if they
342 				 * are system commands.  Otherwise they are
343 				 * printed within parentheses.
344 				 */
345 				if (ki->p_flag & P_SYSTEM) {
346 					fmt_putc('[', &left);
347 					fmt_puts(name, &left);
348 					fmt_putc(']', &left);
349 				} else {
350 					fmt_putc('(', &left);
351 					fmt_puts(name, &left);
352 					fmt_putc(')', &left);
353 				}
354 			}
355 		} else {
356 			fmt_puts(name, &left);
357 		}
358 	}
359 	if (SIMPLEQ_NEXT(ve, next) != NULL && left > 0)
360 		(void)printf("%*s", left, "");
361 }
362 
363 void
364 groups(void *arg, VARENT *ve, int mode)
365 {
366 	struct kinfo_proc2 *ki;
367 	VAR *v;
368 	int left, i;
369 	char buf[16], *p;
370 
371 	if (mode == WIDTHMODE)
372 		return;
373 
374 	ki = arg;
375 	v = ve->var;
376 	if (SIMPLEQ_NEXT(ve, next) != NULL || termwidth != UNLIMITED) {
377 		if (SIMPLEQ_NEXT(ve, next) == NULL) {
378 			left = termwidth - (totwidth - v->width);
379 			if (left < 1) /* already wrapped, just use std width */
380 				left = v->width;
381 		} else
382 			left = v->width;
383 	} else
384 		left = -1;
385 
386 	if (ki->p_ngroups == 0) {
387 		fmt_putc('-', &left);
388 		return;
389 	}
390 
391 	for (i = 0; i < ki->p_ngroups; i++) {
392 		(void)snprintf(buf, sizeof(buf), "%d", ki->p_groups[i]);
393 		if (i)
394 			fmt_putc(' ', &left);
395 		for (p = &buf[0]; *p; p++)
396 			fmt_putc(*p, &left);
397 	}
398 
399 	if (SIMPLEQ_NEXT(ve, next) != NULL && left > 0)
400 		(void)printf("%*s", left, "");
401 }
402 
403 void
404 groupnames(void *arg, VARENT *ve, int mode)
405 {
406 	struct kinfo_proc2 *ki;
407 	VAR *v;
408 	int left, i;
409 	const char *p;
410 
411 	if (mode == WIDTHMODE)
412 		return;
413 
414 	ki = arg;
415 	v = ve->var;
416 	if (SIMPLEQ_NEXT(ve, next) != NULL || termwidth != UNLIMITED) {
417 		if (SIMPLEQ_NEXT(ve, next) == NULL) {
418 			left = termwidth - (totwidth - v->width);
419 			if (left < 1) /* already wrapped, just use std width */
420 				left = v->width;
421 		} else
422 			left = v->width;
423 	} else
424 		left = -1;
425 
426 	if (ki->p_ngroups == 0) {
427 		fmt_putc('-', &left);
428 		return;
429 	}
430 
431 	for (i = 0; i < ki->p_ngroups; i++) {
432 		if (i)
433 			fmt_putc(' ', &left);
434 		for (p = group_from_gid(ki->p_groups[i], 0); *p; p++)
435 			fmt_putc(*p, &left);
436 	}
437 
438 	if (SIMPLEQ_NEXT(ve, next) != NULL && left > 0)
439 		(void)printf("%*s", left, "");
440 }
441 
442 void
443 ucomm(void *arg, VARENT *ve, int mode)
444 {
445 	struct kinfo_proc2 *k;
446 	VAR *v;
447 
448 	k = arg;
449 	v = ve->var;
450 	strprintorsetwidth(v, k->p_comm, mode);
451 }
452 
453 void
454 emul(void *arg, VARENT *ve, int mode)
455 {
456 	struct kinfo_proc2 *k;
457 	VAR *v;
458 
459 	k = arg;
460 	v = ve->var;
461 	strprintorsetwidth(v, k->p_ename, mode);
462 }
463 
464 void
465 logname(void *arg, VARENT *ve, int mode)
466 {
467 	struct kinfo_proc2 *k;
468 	VAR *v;
469 
470 	k = arg;
471 	v = ve->var;
472 	strprintorsetwidth(v, k->p_login, mode);
473 }
474 
475 void
476 state(void *arg, VARENT *ve, int mode)
477 {
478 	struct kinfo_proc2 *k;
479 	int flag, is_zombie;
480 	char *cp;
481 	VAR *v;
482 	char buf[16];
483 
484 	k = arg;
485 	is_zombie = 0;
486 	v = ve->var;
487 	flag = k->p_flag;
488 	cp = buf;
489 
490 	switch (k->p_stat) {
491 
492 	case LSSTOP:
493 		*cp = 'T';
494 		break;
495 
496 	case LSSLEEP:
497 		if (flag & L_SINTR)	/* interruptable (long) */
498 			*cp = k->p_slptime >= maxslp ? 'I' : 'S';
499 		else
500 			*cp = 'D';
501 		break;
502 
503 	case LSRUN:
504 	case LSIDL:
505 		*cp = 'R';
506 		break;
507 
508 	case LSONPROC:
509 		*cp = 'O';
510 		break;
511 
512 	case LSZOMB:
513 		*cp = 'Z';
514 		is_zombie = 1;
515 		break;
516 
517 	case LSSUSPENDED:
518 		*cp = 'U';
519 		break;
520 
521 	default:
522 		*cp = '?';
523 	}
524 	cp++;
525 	if (flag & L_INMEM) {
526 	} else
527 		*cp++ = 'W';
528 	if (k->p_nice < NZERO)
529 		*cp++ = '<';
530 	else if (k->p_nice > NZERO)
531 		*cp++ = 'N';
532 	if (flag & P_TRACED)
533 		*cp++ = 'X';
534 	if (flag & P_WEXIT && !is_zombie)
535 		*cp++ = 'E';
536 	if (flag & P_PPWAIT)
537 		*cp++ = 'V';
538 	if (flag & P_SYSTEM)
539 		*cp++ = 'K';
540 	/* system process might have this too, don't need to double up */
541 	else if (k->p_holdcnt)
542 		*cp++ = 'L';
543 	if (k->p_eflag & EPROC_SLEADER)
544 		*cp++ = 's';
545 	if (flag & P_SA)
546 		*cp++ = 'a';
547 	else if (k->p_nlwps > 1)
548 		*cp++ = 'l';
549 	if ((flag & P_CONTROLT) && k->p__pgid == k->p_tpgid)
550 		*cp++ = '+';
551 	*cp = '\0';
552 	strprintorsetwidth(v, buf, mode);
553 }
554 
555 void
556 lstate(void *arg, VARENT *ve, int mode)
557 {
558 	struct kinfo_lwp *k;
559 	int flag, is_zombie;
560 	char *cp;
561 	VAR *v;
562 	char buf[16];
563 
564 	k = arg;
565 	is_zombie = 0;
566 	v = ve->var;
567 	flag = k->l_flag;
568 	cp = buf;
569 
570 	switch (k->l_stat) {
571 
572 	case LSSTOP:
573 		*cp = 'T';
574 		break;
575 
576 	case LSSLEEP:
577 		if (flag & L_SINTR)	/* interruptible (long) */
578 			*cp = k->l_slptime >= maxslp ? 'I' : 'S';
579 		else
580 			*cp = 'D';
581 		break;
582 
583 	case LSRUN:
584 	case LSIDL:
585 	case LSONPROC:
586 		*cp = 'R';
587 		break;
588 
589 	case LSZOMB:
590 	case LSDEAD:
591 		*cp = 'Z';
592 		is_zombie = 1;
593 		break;
594 
595 	case LSSUSPENDED:
596 		*cp = 'U';
597 		break;
598 
599 	default:
600 		*cp = '?';
601 	}
602 	cp++;
603 	if (flag & L_INMEM) {
604 	} else
605 		*cp++ = 'W';
606 	if (k->l_holdcnt)
607 		*cp++ = 'L';
608 	if (flag & L_DETACHED)
609 		*cp++ = '-';
610 	*cp = '\0';
611 	strprintorsetwidth(v, buf, mode);
612 }
613 
614 void
615 pnice(void *arg, VARENT *ve, int mode)
616 {
617 	struct kinfo_proc2 *k;
618 	VAR *v;
619 
620 	k = arg;
621 	v = ve->var;
622 	intprintorsetwidth(v, k->p_nice - NZERO, mode);
623 }
624 
625 void
626 pri(void *arg, VARENT *ve, int mode)
627 {
628 	struct kinfo_lwp *l;
629 	VAR *v;
630 
631 	l = arg;
632 	v = ve->var;
633 	intprintorsetwidth(v, l->l_priority, mode);
634 }
635 
636 void
637 uname(void *arg, VARENT *ve, int mode)
638 {
639 	struct kinfo_proc2 *k;
640 	VAR *v;
641 
642 	k = arg;
643 	v = ve->var;
644 	strprintorsetwidth(v, user_from_uid(k->p_uid, 0), mode);
645 }
646 
647 void
648 runame(void *arg, VARENT *ve, int mode)
649 {
650 	struct kinfo_proc2 *k;
651 	VAR *v;
652 
653 	k = arg;
654 	v = ve->var;
655 	strprintorsetwidth(v, user_from_uid(k->p_ruid, 0), mode);
656 }
657 
658 void
659 svuname(void *arg, VARENT *ve, int mode)
660 {
661 	struct kinfo_proc2 *k;
662 	VAR *v;
663 
664 	k = arg;
665 	v = ve->var;
666 	strprintorsetwidth(v, user_from_uid(k->p_svuid, 0), mode);
667 }
668 
669 void
670 gname(void *arg, VARENT *ve, int mode)
671 {
672 	struct kinfo_proc2 *k;
673 	VAR *v;
674 
675 	k = arg;
676 	v = ve->var;
677 	strprintorsetwidth(v, group_from_gid(k->p_gid, 0), mode);
678 }
679 
680 void
681 rgname(void *arg, VARENT *ve, int mode)
682 {
683 	struct kinfo_proc2 *k;
684 	VAR *v;
685 
686 	k = arg;
687 	v = ve->var;
688 	strprintorsetwidth(v, group_from_gid(k->p_rgid, 0), mode);
689 }
690 
691 void
692 svgname(void *arg, VARENT *ve, int mode)
693 {
694 	struct kinfo_proc2 *k;
695 	VAR *v;
696 
697 	k = arg;
698 	v = ve->var;
699 	strprintorsetwidth(v, group_from_gid(k->p_svgid, 0), mode);
700 }
701 
702 void
703 tdev(void *arg, VARENT *ve, int mode)
704 {
705 	struct kinfo_proc2 *k;
706 	VAR *v;
707 	dev_t dev;
708 	char buff[16];
709 
710 	k = arg;
711 	v = ve->var;
712 	dev = k->p_tdev;
713 	if (dev == NODEV) {
714 		if (mode == PRINTMODE)
715 			(void)printf("%*s", v->width, "?");
716 		else
717 			if (v->width < 2)
718 				v->width = 2;
719 	} else {
720 		(void)snprintf(buff, sizeof(buff),
721 		    "%lld/%lld", (long long)major(dev), (long long)minor(dev));
722 		strprintorsetwidth(v, buff, mode);
723 	}
724 }
725 
726 void
727 tname(void *arg, VARENT *ve, int mode)
728 {
729 	struct kinfo_proc2 *k;
730 	VAR *v;
731 	dev_t dev;
732 	const char *ttname;
733 	int noctty;
734 
735 	k = arg;
736 	v = ve->var;
737 	dev = k->p_tdev;
738 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL) {
739 		if (mode == PRINTMODE)
740 			(void)printf("%-*s", v->width, "?");
741 		else
742 			if (v->width < 2)
743 				v->width = 2;
744 	} else {
745 		noctty = !(k->p_eflag & EPROC_CTTY) ? 1 : 0;
746 		if (mode == WIDTHMODE) {
747 			int fmtlen;
748 
749 			fmtlen = strlen(ttname) + noctty;
750 			if (v->width < fmtlen)
751 				v->width = fmtlen;
752 		} else {
753 			if (noctty)
754 				(void)printf("%-*s-", v->width - 1, ttname);
755 			else
756 				(void)printf("%-*s", v->width, ttname);
757 		}
758 	}
759 }
760 
761 void
762 longtname(void *arg, VARENT *ve, int mode)
763 {
764 	struct kinfo_proc2 *k;
765 	VAR *v;
766 	dev_t dev;
767 	const char *ttname;
768 
769 	k = arg;
770 	v = ve->var;
771 	dev = k->p_tdev;
772 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL) {
773 		if (mode == PRINTMODE)
774 			(void)printf("%-*s", v->width, "?");
775 		else
776 			if (v->width < 2)
777 				v->width = 2;
778 	} else {
779 		strprintorsetwidth(v, ttname, mode);
780 	}
781 }
782 
783 void
784 started(void *arg, VARENT *ve, int mode)
785 {
786 	struct kinfo_proc2 *k;
787 	VAR *v;
788 	time_t startt;
789 	struct tm *tp;
790 	char buf[100], *cp;
791 
792 	k = arg;
793 	v = ve->var;
794 	if (!k->p_uvalid) {
795 		if (mode == PRINTMODE)
796 			(void)printf("%*s", v->width, "-");
797 		return;
798 	}
799 
800 	startt = k->p_ustart_sec;
801 	tp = localtime(&startt);
802 	if (now == 0)
803 		(void)time(&now);
804 	if (now - k->p_ustart_sec < SECSPERDAY)
805 		/* I *hate* SCCS... */
806 		(void)strftime(buf, sizeof(buf) - 1, "%l:%" "M%p", tp);
807 	else if (now - k->p_ustart_sec < DAYSPERWEEK * SECSPERDAY)
808 		/* I *hate* SCCS... */
809 		(void)strftime(buf, sizeof(buf) - 1, "%a%" "I%p", tp);
810 	else
811 		(void)strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
812 	/* %e and %l can start with a space. */
813 	cp = buf;
814 	if (*cp == ' ')
815 		cp++;
816 	strprintorsetwidth(v, cp, mode);
817 }
818 
819 void
820 lstarted(void *arg, VARENT *ve, int mode)
821 {
822 	struct kinfo_proc2 *k;
823 	VAR *v;
824 	time_t startt;
825 	char buf[100];
826 
827 	k = arg;
828 	v = ve->var;
829 	if (!k->p_uvalid) {
830 		/*
831 		 * Minimum width is less than header - we don't
832 		 * need to check it every time.
833 		 */
834 		if (mode == PRINTMODE)
835 			(void)printf("%*s", v->width, "-");
836 		return;
837 	}
838 	startt = k->p_ustart_sec;
839 
840 	/* assume all times are the same length */
841 	if (mode != WIDTHMODE || v->width == 0) {
842 		(void)strftime(buf, sizeof(buf) -1, "%c",
843 		    localtime(&startt));
844 		strprintorsetwidth(v, buf, mode);
845 	}
846 }
847 
848 void
849 elapsed(void *arg, VARENT *ve, int mode)
850 {
851 	struct kinfo_proc2 *k;
852 	VAR *v;
853 	int32_t origseconds, secs, mins, hours, days;
854 	int fmtlen, printed_something;
855 
856 	k = arg;
857 	v = ve->var;
858 	if (k->p_uvalid == 0) {
859 		origseconds = 0;
860 	} else {
861 		if (now == 0)
862 			(void)time(&now);
863 		origseconds = now - k->p_ustart_sec;
864 		if (origseconds < 0) {
865 			/*
866 			 * Don't try to be fancy if the machine's
867 			 * clock has been rewound to before the
868 			 * process "started".
869 			 */
870 			origseconds = 0;
871 		}
872 	}
873 
874 	secs = origseconds;
875 	mins = secs / SECSPERMIN;
876 	secs %= SECSPERMIN;
877 	hours = mins / MINSPERHOUR;
878 	mins %= MINSPERHOUR;
879 	days = hours / HOURSPERDAY;
880 	hours %= HOURSPERDAY;
881 
882 	if (mode == WIDTHMODE) {
883 		if (origseconds == 0)
884 			/* non-zero so fmtlen is calculated at least once */
885 			origseconds = 1;
886 
887 		if (origseconds > v->longestp) {
888 			v->longestp = origseconds;
889 
890 			if (days > 0) {
891 				/* +9 for "-hh:mm:ss" */
892 				fmtlen = iwidth(days) + 9;
893 			} else if (hours > 0) {
894 				/* +6 for "mm:ss" */
895 				fmtlen = iwidth(hours) + 6;
896 			} else {
897 				/* +3 for ":ss" */
898 				fmtlen = iwidth(mins) + 3;
899 			}
900 
901 			if (fmtlen > v->width)
902 				v->width = fmtlen;
903 		}
904 	} else {
905 		printed_something = 0;
906 		fmtlen = v->width;
907 
908 		if (days > 0) {
909 			(void)printf("%*d", fmtlen - 9, days);
910 			printed_something = 1;
911 		} else if (fmtlen > 9) {
912 			(void)printf("%*s", fmtlen - 9, "");
913 		}
914 		if (fmtlen > 9)
915 			fmtlen = 9;
916 
917 		if (printed_something) {
918 			(void)printf("-%.*d", fmtlen - 7, hours);
919 			printed_something = 1;
920 		} else if (hours > 0) {
921 			(void)printf("%*d", fmtlen - 6, hours);
922 			printed_something = 1;
923 		} else if (fmtlen > 6) {
924 			(void)printf("%*s", fmtlen - 6, "");
925 		}
926 		if (fmtlen > 6)
927 			fmtlen = 6;
928 
929 		/* Don't need to set fmtlen or printed_something any more... */
930 		if (printed_something) {
931 			(void)printf(":%.*d", fmtlen - 4, mins);
932 		} else if (mins > 0) {
933 			(void)printf("%*d", fmtlen - 3, mins);
934 		} else if (fmtlen > 3) {
935 			(void)printf("%*s", fmtlen - 3, "0");
936 		}
937 
938 		(void)printf(":%.2d", secs);
939 	}
940 }
941 
942 void
943 wchan(void *arg, VARENT *ve, int mode)
944 {
945 	struct kinfo_lwp *l;
946 	VAR *v;
947 	char *buf;
948 
949 	l = arg;
950 	v = ve->var;
951 	if (l->l_wchan) {
952 		if (l->l_wmesg) {
953 			strprintorsetwidth(v, l->l_wmesg, mode);
954 			v->width = min(v->width, KI_WMESGLEN);
955 		} else {
956 			(void)asprintf(&buf, "%-*" PRIx64, v->width,
957 			    l->l_wchan);
958 			if (buf == NULL)
959 				err(1, "%s", "");
960 			strprintorsetwidth(v, buf, mode);
961 			v->width = min(v->width, KI_WMESGLEN);
962 			free(buf);
963 		}
964 	} else {
965 		if (mode == PRINTMODE)
966 			(void)printf("%-*s", v->width, "-");
967 	}
968 }
969 
970 #define	pgtok(a)        (((a)*getpagesize())/1024)
971 
972 void
973 vsize(void *arg, VARENT *ve, int mode)
974 {
975 	struct kinfo_proc2 *k;
976 	VAR *v;
977 
978 	k = arg;
979 	v = ve->var;
980 	intprintorsetwidth(v,
981 	    pgtok(k->p_vm_dsize + k->p_vm_ssize + k->p_vm_tsize), mode);
982 }
983 
984 void
985 rssize(void *arg, VARENT *ve, int mode)
986 {
987 	struct kinfo_proc2 *k;
988 	VAR *v;
989 
990 	k = arg;
991 	v = ve->var;
992 	/* XXX don't have info about shared */
993 	intprintorsetwidth(v, pgtok(k->p_vm_rssize), mode);
994 }
995 
996 void
997 p_rssize(void *arg, VARENT *ve, int mode)	/* doesn't account for text */
998 {
999 	struct kinfo_proc2 *k;
1000 	VAR *v;
1001 
1002 	k = arg;
1003 	v = ve->var;
1004 	intprintorsetwidth(v, pgtok(k->p_vm_rssize), mode);
1005 }
1006 
1007 void
1008 setncpu(void)
1009 {
1010 	int mib[2];
1011 	size_t size;
1012 
1013 	mib[0] = CTL_HW;
1014 	mib[1] = HW_NCPU;
1015 	size = sizeof(ncpu);
1016 	if (sysctl(mib, 2, &ncpu, &size, NULL, 0) == -1) {
1017 		ncpu = 0;
1018 		return;
1019 	}
1020 	cp_id = malloc(sizeof(cp_id[0]) * ncpu);
1021 	if (cp_id == NULL)
1022 		err(1, NULL);
1023 	mib[0] = CTL_KERN;
1024 	mib[1] = KERN_CP_ID;
1025 	size = sizeof(cp_id[0]) * ncpu;
1026 	if (sysctl(mib, 2, cp_id, &size, NULL, 0) == -1)
1027 		ncpu = 0;
1028 }
1029 
1030 static int
1031 get_cpunum(u_int64_t id)
1032 {
1033 	int i = 0;
1034 	for (i = 0; i < ncpu; i++)
1035 		if (id == cp_id[i])
1036 			return i;
1037 	return -1;
1038 }
1039 
1040 void
1041 cpuid(void *arg, VARENT *ve, int mode)
1042 {
1043 	struct kinfo_lwp *l;
1044 	VAR *v;
1045 
1046 	l = arg;
1047 	v = ve->var;
1048 	intprintorsetwidth(v, get_cpunum(l->l_cpuid), mode);
1049 }
1050 
1051 void
1052 cputime(void *arg, VARENT *ve, int mode)
1053 {
1054 	struct kinfo_proc2 *k;
1055 	VAR *v;
1056 	int32_t secs;
1057 	int32_t psecs;	/* "parts" of a second. first micro, then centi */
1058 	int fmtlen;
1059 
1060 	k = arg;
1061 	v = ve->var;
1062 
1063 	/*
1064 	 * This counts time spent handling interrupts.  We could
1065 	 * fix this, but it is not 100% trivial (and interrupt
1066 	 * time fractions only work on the sparc anyway).	XXX
1067 	 */
1068 	secs = k->p_rtime_sec;
1069 	psecs = k->p_rtime_usec;
1070 	if (sumrusage) {
1071 		secs += k->p_uctime_sec;
1072 		psecs += k->p_uctime_usec;
1073 	}
1074 	/*
1075 	 * round and scale to 100's
1076 	 */
1077 	psecs = (psecs + 5000) / 10000;
1078 	secs += psecs / 100;
1079 	psecs = psecs % 100;
1080 
1081 	if (mode == WIDTHMODE) {
1082 		/*
1083 		 * Ugg, this is the only field where a value of 0 is longer
1084 		 * than the column title.
1085 		 * Use SECSPERMIN, because secs is divided by that when
1086 		 * passed to iwidth().
1087 		 */
1088 		if (secs == 0)
1089 			secs = SECSPERMIN;
1090 
1091 		if (secs > v->longestp) {
1092 			v->longestp = secs;
1093 			/* "+6" for the ":%02ld.%02ld" in the printf() below */
1094 			fmtlen = iwidth(secs / SECSPERMIN) + 6;
1095 			if (fmtlen > v->width)
1096 				v->width = fmtlen;
1097 		}
1098 	} else {
1099 		(void)printf("%*ld:%02ld.%02ld", v->width - 6,
1100 		    (long)(secs / SECSPERMIN), (long)(secs % SECSPERMIN),
1101 		    (long)psecs);
1102 	}
1103 }
1104 
1105 double
1106 getpcpu(k)
1107 	const struct kinfo_proc2 *k;
1108 {
1109 	static int failure;
1110 
1111 	if (!nlistread)
1112 		failure = (kd) ? donlist() : 1;
1113 	if (failure)
1114 		return (0.0);
1115 
1116 #define	fxtofl(fixpt)	((double)(fixpt) / fscale)
1117 
1118 	/* XXX - I don't like this */
1119 	if (k->p_swtime == 0 || (k->p_flag & L_INMEM) == 0 ||
1120 	    k->p_realstat == SZOMB)
1121 		return (0.0);
1122 	if (rawcpu)
1123 		return (100.0 * fxtofl(k->p_pctcpu));
1124 	return (100.0 * fxtofl(k->p_pctcpu) /
1125 		(1.0 - exp(k->p_swtime * log(ccpu))));
1126 }
1127 
1128 void
1129 pcpu(void *arg, VARENT *ve, int mode)
1130 {
1131 	struct kinfo_proc2 *k;
1132 	VAR *v;
1133 
1134 	k = arg;
1135 	v = ve->var;
1136 	doubleprintorsetwidth(v, getpcpu(k), 1, mode);
1137 }
1138 
1139 double
1140 getpmem(k)
1141 	const struct kinfo_proc2 *k;
1142 {
1143 	static int failure;
1144 	double fracmem;
1145 	int szptudot;
1146 
1147 	if (!nlistread)
1148 		failure = (kd) ? donlist() : 1;
1149 	if (failure)
1150 		return (0.0);
1151 
1152 	if ((k->p_flag & L_INMEM) == 0)
1153 		return (0.0);
1154 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
1155 	szptudot = uspace/getpagesize();
1156 	/* XXX don't have info about shared */
1157 	fracmem = ((float)k->p_vm_rssize + szptudot)/mempages;
1158 	return (100.0 * fracmem);
1159 }
1160 
1161 void
1162 pmem(void *arg, VARENT *ve, int mode)
1163 {
1164 	struct kinfo_proc2 *k;
1165 	VAR *v;
1166 
1167 	k = arg;
1168 	v = ve->var;
1169 	doubleprintorsetwidth(v, getpmem(k), 1, mode);
1170 }
1171 
1172 void
1173 pagein(void *arg, VARENT *ve, int mode)
1174 {
1175 	struct kinfo_proc2 *k;
1176 	VAR *v;
1177 
1178 	k = arg;
1179 	v = ve->var;
1180 	intprintorsetwidth(v, k->p_uvalid ? k->p_uru_majflt : 0, mode);
1181 }
1182 
1183 void
1184 maxrss(void *arg, VARENT *ve, int mode)
1185 {
1186 	VAR *v;
1187 
1188 	v = ve->var;
1189 	/* No need to check width! */
1190 	if (mode == PRINTMODE)
1191 		(void)printf("%*s", v->width, "-");
1192 }
1193 
1194 void
1195 tsize(void *arg, VARENT *ve, int mode)
1196 {
1197 	struct kinfo_proc2 *k;
1198 	VAR *v;
1199 
1200 	k = arg;
1201 	v = ve->var;
1202 	intprintorsetwidth(v, pgtok(k->p_vm_tsize), mode);
1203 }
1204 
1205 /*
1206  * Generic output routines.  Print fields from various prototype
1207  * structures.
1208  */
1209 static void
1210 printval(bp, v, mode)
1211 	void *bp;
1212 	VAR *v;
1213 	int mode;
1214 {
1215 	static char ofmt[32] = "%";
1216 	int width, vok, fmtlen;
1217 	const char *fcp;
1218 	char *cp;
1219 	int64_t val;
1220 	u_int64_t uval;
1221 
1222 	val = 0;	/* XXXGCC -Wuninitialized [hpcarm] */
1223 	uval = 0;	/* XXXGCC -Wuninitialized [hpcarm] */
1224 
1225 	/*
1226 	 * Note that the "INF127" check is nonsensical for types
1227 	 * that are or can be signed.
1228 	 */
1229 #define	GET(type)		(*(type *)bp)
1230 #define	CHK_INF127(n)		(((n) > 127) && (v->flag & INF127) ? 127 : (n))
1231 
1232 #define	VSIGN	1
1233 #define	VUNSIGN	2
1234 #define	VPTR	3
1235 
1236 	if (mode == WIDTHMODE) {
1237 		vok = 0;
1238 		switch (v->type) {
1239 		case CHAR:
1240 			val = GET(char);
1241 			vok = VSIGN;
1242 			break;
1243 		case UCHAR:
1244 			uval = CHK_INF127(GET(u_char));
1245 			vok = VUNSIGN;
1246 			break;
1247 		case SHORT:
1248 			val = GET(short);
1249 			vok = VSIGN;
1250 			break;
1251 		case USHORT:
1252 			uval = CHK_INF127(GET(u_short));
1253 			vok = VUNSIGN;
1254 			break;
1255 		case INT32:
1256 			val = GET(int32_t);
1257 			vok = VSIGN;
1258 			break;
1259 		case INT:
1260 			val = GET(int);
1261 			vok = VSIGN;
1262 			break;
1263 		case UINT:
1264 		case UINT32:
1265 			uval = CHK_INF127(GET(u_int));
1266 			vok = VUNSIGN;
1267 			break;
1268 		case LONG:
1269 			val = GET(long);
1270 			vok = VSIGN;
1271 			break;
1272 		case ULONG:
1273 			uval = CHK_INF127(GET(u_long));
1274 			vok = VUNSIGN;
1275 			break;
1276 		case KPTR:
1277 			uval = GET(u_int64_t);
1278 			vok = VPTR;
1279 			break;
1280 		case KPTR24:
1281 			uval = GET(u_int64_t);
1282 			uval &= 0xffffff;
1283 			vok = VPTR;
1284 			break;
1285 		case INT64:
1286 			val = GET(int64_t);
1287 			vok = VSIGN;
1288 			break;
1289 		case UINT64:
1290 			uval = CHK_INF127(GET(u_int64_t));
1291 			vok = VUNSIGN;
1292 			break;
1293 
1294 		case SIGLIST:
1295 		default:
1296 			/* nothing... */;
1297 		}
1298 		switch (vok) {
1299 		case VSIGN:
1300 			if (val < 0 && val < v->longestn) {
1301 				v->longestn = val;
1302 				fmtlen = iwidth(-val) + 1;
1303 				if (fmtlen > v->width)
1304 					v->width = fmtlen;
1305 			} else if (val > 0 && val > v->longestp) {
1306 				v->longestp = val;
1307 				fmtlen = iwidth(val);
1308 				if (fmtlen > v->width)
1309 					v->width = fmtlen;
1310 			}
1311 			return;
1312 		case VUNSIGN:
1313 			if (uval > v->longestu) {
1314 				v->longestu = uval;
1315 				v->width = iwidth(uval);
1316 			}
1317 			return;
1318 		case VPTR:
1319 			fmtlen = 0;
1320 			while (uval > 0) {
1321 				uval >>= 4;
1322 				fmtlen++;
1323 			}
1324 			if (fmtlen > v->width)
1325 				v->width = fmtlen;
1326 			return;
1327 		}
1328 	}
1329 
1330 	width = v->width;
1331 	cp = ofmt + 1;
1332 	fcp = v->fmt;
1333 	if (v->flag & LJUST)
1334 		*cp++ = '-';
1335 	*cp++ = '*';
1336 	while ((*cp++ = *fcp++) != '\0')
1337 		continue;
1338 
1339 	switch (v->type) {
1340 	case CHAR:
1341 		(void)printf(ofmt, width, GET(char));
1342 		return;
1343 	case UCHAR:
1344 		(void)printf(ofmt, width, CHK_INF127(GET(u_char)));
1345 		return;
1346 	case SHORT:
1347 		(void)printf(ofmt, width, GET(short));
1348 		return;
1349 	case USHORT:
1350 		(void)printf(ofmt, width, CHK_INF127(GET(u_short)));
1351 		return;
1352 	case INT:
1353 		(void)printf(ofmt, width, GET(int));
1354 		return;
1355 	case UINT:
1356 		(void)printf(ofmt, width, CHK_INF127(GET(u_int)));
1357 		return;
1358 	case LONG:
1359 		(void)printf(ofmt, width, GET(long));
1360 		return;
1361 	case ULONG:
1362 		(void)printf(ofmt, width, CHK_INF127(GET(u_long)));
1363 		return;
1364 	case KPTR:
1365 		(void)printf(ofmt, width, GET(u_int64_t));
1366 		return;
1367 	case KPTR24:
1368 		(void)printf(ofmt, width, GET(u_int64_t) & 0xffffff);
1369 		return;
1370 	case INT32:
1371 		(void)printf(ofmt, width, GET(int32_t));
1372 		return;
1373 	case UINT32:
1374 		(void)printf(ofmt, width, CHK_INF127(GET(u_int32_t)));
1375 		return;
1376 	case SIGLIST:
1377 		{
1378 			sigset_t *s = (sigset_t *)(void *)bp;
1379 			size_t i;
1380 #define	SIGSETSIZE	(sizeof(s->__bits) / sizeof(s->__bits[0]))
1381 			char buf[SIGSETSIZE * 8 + 1];
1382 
1383 			for (i = 0; i < SIGSETSIZE; i++)
1384 				(void)snprintf(&buf[i * 8], 9, "%.8x",
1385 				    s->__bits[(SIGSETSIZE - 1) - i]);
1386 
1387 			/* Skip leading zeroes */
1388 			for (i = 0; buf[i] == '0'; i++)
1389 				continue;
1390 
1391 			if (buf[i] == '\0')
1392 				i--;
1393 			strprintorsetwidth(v, buf + i, mode);
1394 #undef SIGSETSIZE
1395 		}
1396 		return;
1397 	case INT64:
1398 		(void)printf(ofmt, width, GET(int64_t));
1399 		return;
1400 	case UINT64:
1401 		(void)printf(ofmt, width, CHK_INF127(GET(u_int64_t)));
1402 		return;
1403 	default:
1404 		errx(1, "unknown type %d", v->type);
1405 	}
1406 #undef GET
1407 #undef CHK_INF127
1408 }
1409 
1410 void
1411 pvar(void *arg, VARENT *ve, int mode)
1412 {
1413 	VAR *v;
1414 
1415 	v = ve->var;
1416 	if (v->flag & UAREA && !((struct kinfo_proc2 *)arg)->p_uvalid) {
1417 		if (mode == PRINTMODE)
1418 			(void)printf("%*s", v->width, "-");
1419 		return;
1420 	}
1421 
1422 	(void)printval((char *)arg + v->off, v, mode);
1423 }
1424 
1425 void
1426 putimeval(void *arg, VARENT *ve, int mode)
1427 {
1428 	VAR *v = ve->var;
1429 	struct kinfo_proc2 *k = arg;
1430 	ulong secs = *(uint32_t *)((char *)arg + v->off);
1431 	ulong usec = *(uint32_t *)((char *)arg + v->off + sizeof (uint32_t));
1432 	int fmtlen;
1433 
1434 	if (!k->p_uvalid) {
1435 		if (mode == PRINTMODE)
1436 			(void)printf("%*s", v->width, "-");
1437 		return;
1438 	}
1439 
1440 	if (mode == WIDTHMODE) {
1441 		if (secs == 0)
1442 			/* non-zero so fmtlen is calculated at least once */
1443 			secs = 1;
1444 		if (secs > v->longestu) {
1445 			v->longestu = secs;
1446 			if (secs <= 999)
1447 				/* sss.ssssss */
1448 				fmtlen = iwidth(secs) + 6 + 1;
1449 			else
1450 				/* hh:mm:ss.ss */
1451 				fmtlen = iwidth((secs + 1) / SECSPERHOUR)
1452 					+ 2 + 1 + 2 + 1 + 2 + 1;
1453 			if (fmtlen > v->width)
1454 				v->width = fmtlen;
1455 		}
1456 		return;
1457 	}
1458 
1459 	if (secs < 999)
1460 		(void)printf( "%*lu.%.6lu", v->width - 6 - 1, secs, usec);
1461 	else {
1462 		uint h, m;
1463 		usec += 5000;
1464 		if (usec >= 1000000) {
1465 			usec -= 1000000;
1466 			secs++;
1467 		}
1468 		m = secs / SECSPERMIN;
1469 		secs -= m * SECSPERMIN;
1470 		h = m / MINSPERHOUR;
1471 		m -= h * MINSPERHOUR;
1472 		(void)printf( "%*u:%.2u:%.2lu.%.2lu", v->width - 9, h, m, secs,
1473 		    usec / 10000u );
1474 	}
1475 }
1476 
1477 void
1478 lname(void *arg, VARENT *ve, int mode)
1479 {
1480 	struct kinfo_lwp *l;
1481 	VAR *v;
1482 
1483 	l = arg;
1484 	v = ve->var;
1485 	if (l->l_name && l->l_name[0] != '\0') {
1486 		strprintorsetwidth(v, l->l_name, mode);
1487 		v->width = min(v->width, KI_LNAMELEN);
1488 	} else {
1489 		if (mode == PRINTMODE)
1490 			(void)printf("%-*s", v->width, "-");
1491 	}
1492 }
1493