xref: /freebsd/bin/ps/print.c (revision 325151a3) 
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  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #if 0
31 #ifndef lint
32 static char sccsid[] = "@(#)print.c	8.6 (Berkeley) 4/16/94";
33 #endif /* not lint */
34 #endif
35 
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 
39 #include <sys/param.h>
40 #include <sys/time.h>
41 #include <sys/resource.h>
42 #include <sys/proc.h>
43 #include <sys/stat.h>
44 
45 #include <sys/mac.h>
46 #include <sys/user.h>
47 #include <sys/sysctl.h>
48 #include <sys/vmmeter.h>
49 
50 #include <err.h>
51 #include <grp.h>
52 #include <langinfo.h>
53 #include <locale.h>
54 #include <math.h>
55 #include <nlist.h>
56 #include <pwd.h>
57 #include <stddef.h>
58 #include <stdint.h>
59 #include <stdio.h>
60 #include <stdlib.h>
61 #include <string.h>
62 #include <unistd.h>
63 #include <vis.h>
64 #include <libxo/xo.h>
65 
66 #include "ps.h"
67 
68 #define	COMMAND_WIDTH	16
69 #define	ARGUMENTS_WIDTH	16
70 
71 #define	ps_pgtok(a)	(((a) * getpagesize()) / 1024)
72 
73 void
74 printheader(void)
75 {
76 	VAR *v;
77 	struct varent *vent;
78 
79 	STAILQ_FOREACH(vent, &varlist, next_ve)
80 		if (*vent->header != '\0')
81 			break;
82 	if (!vent)
83 		return;
84 
85 	STAILQ_FOREACH(vent, &varlist, next_ve) {
86 		v = vent->var;
87 		if (v->flag & LJUST) {
88 			if (STAILQ_NEXT(vent, next_ve) == NULL)	/* last one */
89 				xo_emit("{T:/%s}", vent->header);
90 			else
91 				xo_emit("{T:/%-*s}", v->width, vent->header);
92 		} else
93 			xo_emit("{T:/%*s}", v->width, vent->header);
94 		if (STAILQ_NEXT(vent, next_ve) != NULL)
95 			xo_emit("{P: }");
96 	}
97 	xo_emit("\n");
98 }
99 
100 char *
101 arguments(KINFO *k, VARENT *ve)
102 {
103 	char *vis_args;
104 
105 	if ((vis_args = malloc(strlen(k->ki_args) * 4 + 1)) == NULL)
106 		xo_errx(1, "malloc failed");
107 	strvis(vis_args, k->ki_args, VIS_TAB | VIS_NL | VIS_NOSLASH);
108 
109 	if (STAILQ_NEXT(ve, next_ve) != NULL && strlen(vis_args) > ARGUMENTS_WIDTH)
110 		vis_args[ARGUMENTS_WIDTH] = '\0';
111 
112 	return (vis_args);
113 }
114 
115 char *
116 command(KINFO *k, VARENT *ve)
117 {
118 	char *vis_args, *vis_env, *str;
119 
120 	if (cflag) {
121 		/* If it is the last field, then don't pad */
122 		if (STAILQ_NEXT(ve, next_ve) == NULL) {
123 			asprintf(&str, "%s%s%s%s",
124 			    k->ki_d.prefix ? k->ki_d.prefix : "",
125 			    k->ki_p->ki_comm,
126 			    (showthreads && k->ki_p->ki_numthreads > 1) ? "/" : "",
127 			    (showthreads && k->ki_p->ki_numthreads > 1) ? k->ki_p->ki_tdname : "");
128 		} else
129 			str = strdup(k->ki_p->ki_comm);
130 
131 		return (str);
132 	}
133 	if ((vis_args = malloc(strlen(k->ki_args) * 4 + 1)) == NULL)
134 		xo_errx(1, "malloc failed");
135 	strvis(vis_args, k->ki_args, VIS_TAB | VIS_NL | VIS_NOSLASH);
136 
137 	if (STAILQ_NEXT(ve, next_ve) == NULL) {
138 		/* last field */
139 
140 		if (k->ki_env) {
141 			if ((vis_env = malloc(strlen(k->ki_env) * 4 + 1))
142 			    == NULL)
143 				xo_errx(1, "malloc failed");
144 			strvis(vis_env, k->ki_env,
145 			    VIS_TAB | VIS_NL | VIS_NOSLASH);
146 		} else
147 			vis_env = NULL;
148 
149 		asprintf(&str, "%s%s%s%s",
150 		    k->ki_d.prefix ? k->ki_d.prefix : "",
151 		    vis_env ? vis_env : "",
152 		    vis_env ? " " : "",
153 		    vis_args);
154 
155 		if (vis_env != NULL)
156 			free(vis_env);
157 		free(vis_args);
158 	} else {
159 		/* ki_d.prefix & ki_env aren't shown for interim fields */
160 		str = vis_args;
161 
162 		if (strlen(str) > COMMAND_WIDTH)
163 			str[COMMAND_WIDTH] = '\0';
164 	}
165 
166 	return (str);
167 }
168 
169 char *
170 ucomm(KINFO *k, VARENT *ve)
171 {
172 	char *str;
173 
174 	if (STAILQ_NEXT(ve, next_ve) == NULL) {	/* last field, don't pad */
175 		asprintf(&str, "%s%s%s%s",
176 		    k->ki_d.prefix ? k->ki_d.prefix : "",
177 		    k->ki_p->ki_comm,
178 		    (showthreads && k->ki_p->ki_numthreads > 1) ? "/" : "",
179 		    (showthreads && k->ki_p->ki_numthreads > 1) ? k->ki_p->ki_tdname : "");
180 	} else {
181 		if (showthreads && k->ki_p->ki_numthreads > 1)
182 			asprintf(&str, "%s/%s", k->ki_p->ki_comm, k->ki_p->ki_tdname);
183 		else
184 			str = strdup(k->ki_p->ki_comm);
185 	}
186 	return (str);
187 }
188 
189 char *
190 tdnam(KINFO *k, VARENT *ve __unused)
191 {
192 	char *str;
193 
194 	if (showthreads && k->ki_p->ki_numthreads > 1)
195 		str = strdup(k->ki_p->ki_tdname);
196 	else
197 		str = strdup("      ");
198 
199 	return (str);
200 }
201 
202 char *
203 logname(KINFO *k, VARENT *ve __unused)
204 {
205 
206 	if (*k->ki_p->ki_login == '\0')
207 		return (NULL);
208 	return (strdup(k->ki_p->ki_login));
209 }
210 
211 char *
212 state(KINFO *k, VARENT *ve __unused)
213 {
214 	int flag, tdflags;
215 	char *cp, *buf;
216 
217 	buf = malloc(16);
218 	if (buf == NULL)
219 		xo_errx(1, "malloc failed");
220 
221 	flag = k->ki_p->ki_flag;
222 	tdflags = k->ki_p->ki_tdflags;	/* XXXKSE */
223 	cp = buf;
224 
225 	switch (k->ki_p->ki_stat) {
226 
227 	case SSTOP:
228 		*cp = 'T';
229 		break;
230 
231 	case SSLEEP:
232 		if (tdflags & TDF_SINTR)	/* interruptable (long) */
233 			*cp = k->ki_p->ki_slptime >= MAXSLP ? 'I' : 'S';
234 		else
235 			*cp = 'D';
236 		break;
237 
238 	case SRUN:
239 	case SIDL:
240 		*cp = 'R';
241 		break;
242 
243 	case SWAIT:
244 		*cp = 'W';
245 		break;
246 
247 	case SLOCK:
248 		*cp = 'L';
249 		break;
250 
251 	case SZOMB:
252 		*cp = 'Z';
253 		break;
254 
255 	default:
256 		*cp = '?';
257 	}
258 	cp++;
259 	if (!(flag & P_INMEM))
260 		*cp++ = 'W';
261 	if (k->ki_p->ki_nice < NZERO)
262 		*cp++ = '<';
263 	else if (k->ki_p->ki_nice > NZERO)
264 		*cp++ = 'N';
265 	if (flag & P_TRACED)
266 		*cp++ = 'X';
267 	if (flag & P_WEXIT && k->ki_p->ki_stat != SZOMB)
268 		*cp++ = 'E';
269 	if (flag & P_PPWAIT)
270 		*cp++ = 'V';
271 	if ((flag & P_SYSTEM) || k->ki_p->ki_lock > 0)
272 		*cp++ = 'L';
273 	if (k->ki_p->ki_kiflag & KI_SLEADER)
274 		*cp++ = 's';
275 	if ((flag & P_CONTROLT) && k->ki_p->ki_pgid == k->ki_p->ki_tpgid)
276 		*cp++ = '+';
277 	if (flag & P_JAILED)
278 		*cp++ = 'J';
279 	*cp = '\0';
280 	return (buf);
281 }
282 
283 #define	scalepri(x)	((x) - PZERO)
284 
285 char *
286 pri(KINFO *k, VARENT *ve __unused)
287 {
288 	char *str;
289 
290 	asprintf(&str, "%d", scalepri(k->ki_p->ki_pri.pri_level));
291 	return (str);
292 }
293 
294 char *
295 upr(KINFO *k, VARENT *ve __unused)
296 {
297 	char *str;
298 
299 	asprintf(&str, "%d", scalepri(k->ki_p->ki_pri.pri_user));
300 	return (str);
301 }
302 #undef scalepri
303 
304 char *
305 uname(KINFO *k, VARENT *ve __unused)
306 {
307 
308 	return (strdup(user_from_uid(k->ki_p->ki_uid, 0)));
309 }
310 
311 char *
312 egroupname(KINFO *k, VARENT *ve __unused)
313 {
314 
315 	return (strdup(group_from_gid(k->ki_p->ki_groups[0], 0)));
316 }
317 
318 char *
319 rgroupname(KINFO *k, VARENT *ve __unused)
320 {
321 
322 	return (strdup(group_from_gid(k->ki_p->ki_rgid, 0)));
323 }
324 
325 char *
326 runame(KINFO *k, VARENT *ve __unused)
327 {
328 
329 	return (strdup(user_from_uid(k->ki_p->ki_ruid, 0)));
330 }
331 
332 char *
333 tdev(KINFO *k, VARENT *ve __unused)
334 {
335 	dev_t dev;
336 	char *str;
337 
338 	dev = k->ki_p->ki_tdev;
339 	if (dev == NODEV)
340 		str = strdup("-");
341 	else
342 		asprintf(&str, "%#jx", (uintmax_t)dev);
343 
344 	return (str);
345 }
346 
347 char *
348 tname(KINFO *k, VARENT *ve __unused)
349 {
350 	dev_t dev;
351 	char *ttname, *str;
352 
353 	dev = k->ki_p->ki_tdev;
354 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
355 		str = strdup("- ");
356 	else {
357 		if (strncmp(ttname, "tty", 3) == 0 ||
358 		    strncmp(ttname, "cua", 3) == 0)
359 			ttname += 3;
360 		if (strncmp(ttname, "pts/", 4) == 0)
361 			ttname += 4;
362 		asprintf(&str, "%s%c", ttname,
363 		    k->ki_p->ki_kiflag & KI_CTTY ? ' ' : '-');
364 	}
365 
366 	return (str);
367 }
368 
369 char *
370 longtname(KINFO *k, VARENT *ve __unused)
371 {
372 	dev_t dev;
373 	const char *ttname;
374 
375 	dev = k->ki_p->ki_tdev;
376 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
377 		ttname = "-";
378 
379 	return (strdup(ttname));
380 }
381 
382 char *
383 started(KINFO *k, VARENT *ve __unused)
384 {
385 	time_t then;
386 	struct tm *tp;
387 	size_t buflen = 100;
388 	char *buf;
389 
390 	if (!k->ki_valid)
391 		return (NULL);
392 
393 	buf = malloc(buflen);
394 	if (buf == NULL)
395 		xo_errx(1, "malloc failed");
396 
397 	then = k->ki_p->ki_start.tv_sec;
398 	tp = localtime(&then);
399 	if (now - k->ki_p->ki_start.tv_sec < 24 * 3600) {
400 		(void)strftime(buf, buflen, "%H:%M  ", tp);
401 	} else if (now - k->ki_p->ki_start.tv_sec < 7 * 86400) {
402 		(void)strftime(buf, buflen, "%a%H  ", tp);
403 	} else
404 		(void)strftime(buf, buflen, "%e%b%y", tp);
405 	return (buf);
406 }
407 
408 char *
409 lstarted(KINFO *k, VARENT *ve __unused)
410 {
411 	time_t then;
412 	char *buf;
413 	size_t buflen = 100;
414 
415 	if (!k->ki_valid)
416 		return (NULL);
417 
418 	buf = malloc(buflen);
419 	if (buf == NULL)
420 		xo_errx(1, "malloc failed");
421 
422 	then = k->ki_p->ki_start.tv_sec;
423 	(void)strftime(buf, buflen, "%c", localtime(&then));
424 	return (buf);
425 }
426 
427 char *
428 lockname(KINFO *k, VARENT *ve __unused)
429 {
430 	char *str;
431 
432 	if (k->ki_p->ki_kiflag & KI_LOCKBLOCK) {
433 		if (k->ki_p->ki_lockname[0] != 0)
434 			str = strdup(k->ki_p->ki_lockname);
435 		else
436 			str = strdup("???");
437 	} else
438 		str = NULL;
439 
440 	return (str);
441 }
442 
443 char *
444 wchan(KINFO *k, VARENT *ve __unused)
445 {
446 	char *str;
447 
448 	if (k->ki_p->ki_wchan) {
449 		if (k->ki_p->ki_wmesg[0] != 0)
450 			str = strdup(k->ki_p->ki_wmesg);
451 		else
452 			asprintf(&str, "%lx", (long)k->ki_p->ki_wchan);
453 	} else
454 		str = NULL;
455 
456 	return (str);
457 }
458 
459 char *
460 nwchan(KINFO *k, VARENT *ve __unused)
461 {
462 	char *str;
463 
464 	if (k->ki_p->ki_wchan)
465 		asprintf(&str, "%0lx", (long)k->ki_p->ki_wchan);
466 	else
467 		str = NULL;
468 
469 	return (str);
470 }
471 
472 char *
473 mwchan(KINFO *k, VARENT *ve __unused)
474 {
475 	char *str;
476 
477 	if (k->ki_p->ki_wchan) {
478 		if (k->ki_p->ki_wmesg[0] != 0)
479 			str = strdup(k->ki_p->ki_wmesg);
480 		else
481                         asprintf(&str, "%lx", (long)k->ki_p->ki_wchan);
482 	} else if (k->ki_p->ki_kiflag & KI_LOCKBLOCK) {
483 		if (k->ki_p->ki_lockname[0]) {
484 			str = strdup(k->ki_p->ki_lockname);
485 		} else
486 			str = strdup("???");
487 	} else
488 		str = NULL;
489 
490 	return (str);
491 }
492 
493 char *
494 vsize(KINFO *k, VARENT *ve __unused)
495 {
496 	char *str;
497 
498 	asprintf(&str, "%lu", (u_long)(k->ki_p->ki_size / 1024));
499 	return (str);
500 }
501 
502 static char *
503 printtime(KINFO *k, VARENT *ve __unused, long secs, long psecs)
504 /* psecs is "parts" of a second. first micro, then centi */
505 {
506 	static char decimal_point;
507 	char *str;
508 
509 	if (decimal_point == '\0')
510 		decimal_point = localeconv()->decimal_point[0];
511 	if (!k->ki_valid) {
512 		secs = 0;
513 		psecs = 0;
514 	} else {
515 		/* round and scale to 100's */
516 		psecs = (psecs + 5000) / 10000;
517 		secs += psecs / 100;
518 		psecs = psecs % 100;
519 	}
520 	asprintf(&str, "%ld:%02ld%c%02ld",
521 	    secs / 60, secs % 60, decimal_point, psecs);
522 	return (str);
523 }
524 
525 char *
526 cputime(KINFO *k, VARENT *ve)
527 {
528 	long secs, psecs;
529 
530 	/*
531 	 * This counts time spent handling interrupts.  We could
532 	 * fix this, but it is not 100% trivial (and interrupt
533 	 * time fractions only work on the sparc anyway).	XXX
534 	 */
535 	secs = k->ki_p->ki_runtime / 1000000;
536 	psecs = k->ki_p->ki_runtime % 1000000;
537 	if (sumrusage) {
538 		secs += k->ki_p->ki_childtime.tv_sec;
539 		psecs += k->ki_p->ki_childtime.tv_usec;
540 	}
541 	return (printtime(k, ve, secs, psecs));
542 }
543 
544 char *
545 systime(KINFO *k, VARENT *ve)
546 {
547 	long secs, psecs;
548 
549 	secs = k->ki_p->ki_rusage.ru_stime.tv_sec;
550 	psecs = k->ki_p->ki_rusage.ru_stime.tv_usec;
551 	if (sumrusage) {
552 		secs += k->ki_p->ki_childstime.tv_sec;
553 		psecs += k->ki_p->ki_childstime.tv_usec;
554 	}
555 	return (printtime(k, ve, secs, psecs));
556 }
557 
558 char *
559 usertime(KINFO *k, VARENT *ve)
560 {
561 	long secs, psecs;
562 
563 	secs = k->ki_p->ki_rusage.ru_utime.tv_sec;
564 	psecs = k->ki_p->ki_rusage.ru_utime.tv_usec;
565 	if (sumrusage) {
566 		secs += k->ki_p->ki_childutime.tv_sec;
567 		psecs += k->ki_p->ki_childutime.tv_usec;
568 	}
569 	return (printtime(k, ve, secs, psecs));
570 }
571 
572 char *
573 elapsed(KINFO *k, VARENT *ve __unused)
574 {
575 	time_t val;
576 	int days, hours, mins, secs;
577 	char *str;
578 
579 	if (!k->ki_valid)
580 		return (NULL);
581 	val = now - k->ki_p->ki_start.tv_sec;
582 	days = val / (24 * 60 * 60);
583 	val %= 24 * 60 * 60;
584 	hours = val / (60 * 60);
585 	val %= 60 * 60;
586 	mins = val / 60;
587 	secs = val % 60;
588 	if (days != 0)
589 		asprintf(&str, "%3d-%02d:%02d:%02d", days, hours, mins, secs);
590 	else if (hours != 0)
591 		asprintf(&str, "%02d:%02d:%02d", hours, mins, secs);
592 	else
593 		asprintf(&str, "%02d:%02d", mins, secs);
594 
595 	return (str);
596 }
597 
598 char *
599 elapseds(KINFO *k, VARENT *ve __unused)
600 {
601 	time_t val;
602 	char *str;
603 
604 	if (!k->ki_valid)
605 		return (NULL);
606 	val = now - k->ki_p->ki_start.tv_sec;
607 	asprintf(&str, "%jd", (intmax_t)val);
608 	return (str);
609 }
610 
611 double
612 getpcpu(const KINFO *k)
613 {
614 	static int failure;
615 
616 	if (!nlistread)
617 		failure = donlist();
618 	if (failure)
619 		return (0.0);
620 
621 #define	fxtofl(fixpt)	((double)(fixpt) / fscale)
622 
623 	/* XXX - I don't like this */
624 	if (k->ki_p->ki_swtime == 0 || (k->ki_p->ki_flag & P_INMEM) == 0)
625 		return (0.0);
626 	if (rawcpu)
627 		return (100.0 * fxtofl(k->ki_p->ki_pctcpu));
628 	return (100.0 * fxtofl(k->ki_p->ki_pctcpu) /
629 		(1.0 - exp(k->ki_p->ki_swtime * log(fxtofl(ccpu)))));
630 }
631 
632 char *
633 pcpu(KINFO *k, VARENT *ve __unused)
634 {
635 	char *str;
636 
637 	asprintf(&str, "%.1f", getpcpu(k));
638 	return (str);
639 }
640 
641 static double
642 getpmem(KINFO *k)
643 {
644 	static int failure;
645 	double fracmem;
646 
647 	if (!nlistread)
648 		failure = donlist();
649 	if (failure)
650 		return (0.0);
651 
652 	if ((k->ki_p->ki_flag & P_INMEM) == 0)
653 		return (0.0);
654 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
655 	/* XXX don't have info about shared */
656 	fracmem = ((float)k->ki_p->ki_rssize) / mempages;
657 	return (100.0 * fracmem);
658 }
659 
660 char *
661 pmem(KINFO *k, VARENT *ve __unused)
662 {
663 	char *str;
664 
665 	asprintf(&str, "%.1f", getpmem(k));
666 	return (str);
667 }
668 
669 char *
670 pagein(KINFO *k, VARENT *ve __unused)
671 {
672 	char *str;
673 
674 	asprintf(&str, "%ld", k->ki_valid ? k->ki_p->ki_rusage.ru_majflt : 0);
675 	return (str);
676 }
677 
678 /* ARGSUSED */
679 char *
680 maxrss(KINFO *k __unused, VARENT *ve __unused)
681 {
682 
683 	/* XXX not yet */
684 	return (NULL);
685 }
686 
687 char *
688 priorityr(KINFO *k, VARENT *ve __unused)
689 {
690 	struct priority *lpri;
691 	char *str;
692 	unsigned class, level;
693 
694 	lpri = &k->ki_p->ki_pri;
695 	class = lpri->pri_class;
696 	level = lpri->pri_level;
697 	switch (class) {
698 	case PRI_ITHD:
699 		asprintf(&str, "intr:%u", level);
700 		break;
701 	case PRI_REALTIME:
702 		asprintf(&str, "real:%u", level);
703 		break;
704 	case PRI_TIMESHARE:
705 		asprintf(&str, "normal");
706 		break;
707 	case PRI_IDLE:
708 		asprintf(&str, "idle:%u", level);
709 		break;
710 	default:
711 		asprintf(&str, "%u:%u", class, level);
712 		break;
713 	}
714 	return (str);
715 }
716 
717 /*
718  * Generic output routines.  Print fields from various prototype
719  * structures.
720  */
721 static char *
722 printval(void *bp, VAR *v)
723 {
724 	static char ofmt[32] = "%";
725 	const char *fcp;
726 	char *cp, *str;
727 
728 	cp = ofmt + 1;
729 	fcp = v->fmt;
730 	while ((*cp++ = *fcp++));
731 
732 #define	CHKINF127(n)	(((n) > 127) && (v->flag & INF127) ? 127 : (n))
733 
734 	switch (v->type) {
735 	case CHAR:
736 		(void)asprintf(&str, ofmt, *(char *)bp);
737 		break;
738 	case UCHAR:
739 		(void)asprintf(&str, ofmt, *(u_char *)bp);
740 		break;
741 	case SHORT:
742 		(void)asprintf(&str, ofmt, *(short *)bp);
743 		break;
744 	case USHORT:
745 		(void)asprintf(&str, ofmt, *(u_short *)bp);
746 		break;
747 	case INT:
748 		(void)asprintf(&str, ofmt, *(int *)bp);
749 		break;
750 	case UINT:
751 		(void)asprintf(&str, ofmt, CHKINF127(*(u_int *)bp));
752 		break;
753 	case LONG:
754 		(void)asprintf(&str, ofmt, *(long *)bp);
755 		break;
756 	case ULONG:
757 		(void)asprintf(&str, ofmt, *(u_long *)bp);
758 		break;
759 	case KPTR:
760 		(void)asprintf(&str, ofmt, *(u_long *)bp);
761 		break;
762 	case PGTOK:
763 		(void)asprintf(&str, ofmt, ps_pgtok(*(u_long *)bp));
764 		break;
765 	default:
766 		xo_errx(1, "unknown type %d", v->type);
767 	}
768 
769 	return (str);
770 }
771 
772 char *
773 kvar(KINFO *k, VARENT *ve)
774 {
775 	VAR *v;
776 
777 	v = ve->var;
778 	return (printval((char *)((char *)k->ki_p + v->off), v));
779 }
780 
781 char *
782 rvar(KINFO *k, VARENT *ve)
783 {
784 	VAR *v;
785 
786 	v = ve->var;
787 	if (!k->ki_valid)
788 		return (NULL);
789 	return (printval((char *)((char *)(&k->ki_p->ki_rusage) + v->off), v));
790 }
791 
792 char *
793 emulname(KINFO *k, VARENT *ve __unused)
794 {
795 
796 	return (strdup(k->ki_p->ki_emul));
797 }
798 
799 char *
800 label(KINFO *k, VARENT *ve __unused)
801 {
802 	char *string;
803 	mac_t proclabel;
804 	int error;
805 
806 	string = NULL;
807 	if (mac_prepare_process_label(&proclabel) == -1) {
808 		xo_warn("mac_prepare_process_label");
809 		goto out;
810 	}
811 	error = mac_get_pid(k->ki_p->ki_pid, proclabel);
812 	if (error == 0) {
813 		if (mac_to_text(proclabel, &string) == -1)
814 			string = NULL;
815 	}
816 	mac_free(proclabel);
817 out:
818 	return (string);
819 }
820 
821 char *
822 loginclass(KINFO *k, VARENT *ve __unused)
823 {
824 
825 	/*
826 	 * Don't display login class for system processes;
827 	 * login classes are used for resource limits,
828 	 * and limits don't apply to system processes.
829 	 */
830 	if (k->ki_p->ki_flag & P_SYSTEM) {
831 		return (strdup("-"));
832 	}
833 	return (strdup(k->ki_p->ki_loginclass));
834 }
835