xref: /dragonfly/bin/ps/print.c (revision 38a690d7) 
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.7 2003/07/25 05:28:53 dillon Exp $
36  */
37 
38 #include <sys/param.h>
39 #include <sys/time.h>
40 #include <sys/resource.h>
41 #include <sys/proc.h>
42 #include <sys/stat.h>
43 
44 #include <sys/ucred.h>
45 #include <sys/user.h>
46 #include <sys/sysctl.h>
47 #include <sys/rtprio.h>
48 #include <vm/vm.h>
49 
50 #include <err.h>
51 #include <langinfo.h>
52 #include <locale.h>
53 #include <math.h>
54 #include <nlist.h>
55 #include <stddef.h>
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <unistd.h>
59 #include <string.h>
60 #include <vis.h>
61 
62 #include "ps.h"
63 
64 void
65 printheader()
66 {
67 	VAR *v;
68 	struct varent *vent;
69 	int allempty;
70 
71 	allempty = 1;
72 	for (vent = vhead; vent; vent = vent->next)
73 		if (*vent->var->header != '\0') {
74 			allempty = 0;
75 			break;
76 		}
77 	if (allempty)
78 		return;
79 	for (vent = vhead; vent; vent = vent->next) {
80 		v = vent->var;
81 		if (v->flag & LJUST) {
82 			if (vent->next == NULL)	/* last one */
83 				(void)printf("%s", v->header);
84 			else
85 				(void)printf("%-*s", v->width, v->header);
86 		} else
87 			(void)printf("%*s", v->width, v->header);
88 		if (vent->next != NULL)
89 			(void)putchar(' ');
90 	}
91 	(void)putchar('\n');
92 }
93 
94 void
95 command(k, ve)
96 	KINFO *k;
97 	VARENT *ve;
98 {
99 	VAR *v;
100 	int left;
101 	char *cp, *vis_env, *vis_args;
102 
103 	v = ve->var;
104 
105 	if (cflag) {
106 		if (ve->next == NULL)	/* last field, don't pad */
107 			(void)printf("%s", KI_THREAD(k)->td_comm);
108 		else
109 			(void)printf("%-*s", v->width, KI_THREAD(k)->td_comm);
110 		return;
111 	}
112 
113 	if ((vis_args = malloc(strlen(k->ki_args) * 4 + 1)) == NULL)
114 		err(1, NULL);
115 	strvis(vis_args, k->ki_args, VIS_TAB | VIS_NL | VIS_NOSLASH);
116 	if (k->ki_env) {
117 		if ((vis_env = malloc(strlen(k->ki_env) * 4 + 1)) == NULL)
118 			err(1, NULL);
119 		strvis(vis_env, k->ki_env, VIS_TAB | VIS_NL | VIS_NOSLASH);
120 	} else
121 		vis_env = NULL;
122 
123 	if (ve->next == NULL) {
124 		/* last field */
125 		if (termwidth == UNLIMITED) {
126 			if (vis_env)
127 				(void)printf("%s ", vis_env);
128 			(void)printf("%s", vis_args);
129 		} else {
130 			left = termwidth - (totwidth - v->width);
131 			if (left < 1) /* already wrapped, just use std width */
132 				left = v->width;
133 			if ((cp = vis_env) != NULL) {
134 				while (--left >= 0 && *cp)
135 					(void)putchar(*cp++);
136 				if (--left >= 0)
137 					putchar(' ');
138 			}
139 			for (cp = vis_args; --left >= 0 && *cp != '\0';)
140 				(void)putchar(*cp++);
141 		}
142 	} else
143 		/* XXX env? */
144 		(void)printf("%-*.*s", v->width, v->width, vis_args);
145 	free(vis_args);
146 	if (vis_env != NULL)
147 		free(vis_env);
148 }
149 
150 void
151 ucomm(k, ve)
152 	KINFO *k;
153 	VARENT *ve;
154 {
155 	VAR *v;
156 
157 	v = ve->var;
158 	(void)printf("%-*s", v->width, KI_THREAD(k)->td_comm);
159 }
160 
161 void
162 logname(k, ve)
163 	KINFO *k;
164 	VARENT *ve;
165 {
166 	VAR *v;
167 	char *s;
168 
169 	v = ve->var;
170 	(void)printf("%-*s", v->width, (s = KI_EPROC(k)->e_login, *s) ? s : "-");
171 }
172 
173 void
174 state(k, ve)
175 	KINFO *k;
176 	VARENT *ve;
177 {
178 	struct proc *p;
179 	int flag;
180 	char *cp;
181 	VAR *v;
182 	char buf[16];
183 
184 	v = ve->var;
185 	p = KI_PROC(k);
186 	flag = p->p_flag;
187 	cp = buf;
188 
189 	switch (p->p_stat) {
190 
191 	case SSTOP:
192 		*cp = 'T';
193 		break;
194 
195 	case SSLEEP:
196 		if (flag & P_SINTR)	/* interruptable (long) */
197 			*cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
198 		else
199 			*cp = 'D';
200 		break;
201 
202 	case SRUN:
203 	case SIDL:
204 		*cp = 'R';
205 		if (KI_THREAD(k)->td_flags & TDF_RUNNING) {
206 		    ++cp;
207 		    sprintf(cp, "%d", KI_EPROC(k)->e_cpuid);
208 		    while (cp[1])
209 			++cp;
210 		}
211 		break;
212 
213 	case SZOMB:
214 		*cp = 'Z';
215 		break;
216 
217 	default:
218 		*cp = '?';
219 	}
220 	cp++;
221 	if (!(flag & P_INMEM))
222 		*cp++ = 'W';
223 	if (p->p_nice < NZERO)
224 		*cp++ = '<';
225 	else if (p->p_nice > NZERO)
226 		*cp++ = 'N';
227 	if (flag & P_TRACED)
228 		*cp++ = 'X';
229 	if (flag & P_WEXIT && p->p_stat != SZOMB)
230 		*cp++ = 'E';
231 	if (flag & P_PPWAIT)
232 		*cp++ = 'V';
233 	if ((flag & P_SYSTEM) || p->p_lock > 0)
234 		*cp++ = 'L';
235 	if (KI_EPROC(k)->e_flag & EPROC_SLEADER)
236 		*cp++ = 's';
237 	if ((flag & P_CONTROLT) && KI_EPROC(k)->e_pgid == KI_EPROC(k)->e_tpgid)
238 		*cp++ = '+';
239 	if (flag & P_JAILED)
240 		*cp++ = 'J';
241 	*cp = '\0';
242 	(void)printf("%-*s", v->width, buf);
243 }
244 
245 void
246 pri(k, ve)
247 	KINFO *k;
248 	VARENT *ve;
249 {
250 	VAR *v;
251 
252 	v = ve->var;
253 	(void)printf("%*d", v->width, KI_PROC(k)->p_priority);
254 }
255 
256 void
257 uname(k, ve)
258 	KINFO *k;
259 	VARENT *ve;
260 {
261 	VAR *v;
262 
263 	v = ve->var;
264 	(void)printf("%-*s",
265 	    (int)v->width, user_from_uid(KI_EPROC(k)->e_ucred.cr_uid, 0));
266 }
267 
268 int
269 s_uname(k)
270 	KINFO *k;
271 {
272 	    return (strlen(user_from_uid(KI_EPROC(k)->e_ucred.cr_uid, 0)));
273 }
274 
275 void
276 runame(k, ve)
277 	KINFO *k;
278 	VARENT *ve;
279 {
280 	VAR *v;
281 
282 	v = ve->var;
283 	(void)printf("%-*s",
284 	    (int)v->width, user_from_uid(KI_EPROC(k)->e_ucred.cr_ruid, 0));
285 }
286 
287 int
288 s_runame(k)
289 	KINFO *k;
290 {
291 	    return (strlen(user_from_uid(KI_EPROC(k)->e_ucred.cr_ruid, 0)));
292 }
293 
294 void
295 tdev(k, ve)
296 	KINFO *k;
297 	VARENT *ve;
298 {
299 	VAR *v;
300 	dev_t dev;
301 	char buff[16];
302 
303 	v = ve->var;
304 	dev = KI_EPROC(k)->e_tdev;
305 	if (dev == NODEV)
306 		(void)printf("%*s", v->width, "??");
307 	else {
308 		(void)snprintf(buff, sizeof(buff),
309 		    "%d/%d", major(dev), minor(dev));
310 		(void)printf("%*s", v->width, buff);
311 	}
312 }
313 
314 void
315 tname(k, ve)
316 	KINFO *k;
317 	VARENT *ve;
318 {
319 	VAR *v;
320 	dev_t dev;
321 	char *ttname;
322 
323 	v = ve->var;
324 	dev = KI_EPROC(k)->e_tdev;
325 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
326 		(void)printf("%*s ", v->width-1, "??");
327 	else {
328 		if (strncmp(ttname, "tty", 3) == 0 ||
329 		    strncmp(ttname, "cua", 3) == 0)
330 			ttname += 3;
331 		(void)printf("%*.*s%c", v->width-1, v->width-1, ttname,
332 			KI_EPROC(k)->e_flag & EPROC_CTTY ? ' ' : '-');
333 	}
334 }
335 
336 void
337 longtname(k, ve)
338 	KINFO *k;
339 	VARENT *ve;
340 {
341 	VAR *v;
342 	dev_t dev;
343 	char *ttname;
344 
345 	v = ve->var;
346 	dev = KI_EPROC(k)->e_tdev;
347 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
348 		(void)printf("%-*s", v->width, "??");
349 	else
350 		(void)printf("%-*s", v->width, ttname);
351 }
352 
353 void
354 started(k, ve)
355 	KINFO *k;
356 	VARENT *ve;
357 {
358 	VAR *v;
359 	static time_t now;
360 	time_t then;
361 	struct tm *tp;
362 	char buf[100];
363 	static int  use_ampm = -1;
364 
365 	v = ve->var;
366 	if (!k->ki_u.u_valid) {
367 		(void)printf("%-*s", v->width, "-");
368 		return;
369 	}
370 
371 	if (use_ampm < 0)
372 		use_ampm = (*nl_langinfo(T_FMT_AMPM) != '\0');
373 
374 	then = k->ki_u.u_start.tv_sec;
375 	tp = localtime(&then);
376 	if (!now)
377 		(void)time(&now);
378 	if (now - k->ki_u.u_start.tv_sec < 24 * 3600) {
379 		(void)strftime(buf, sizeof(buf) - 1,
380 		use_ampm ? "%l:%M%p" : "%k:%M  ", tp);
381 	} else if (now - k->ki_u.u_start.tv_sec < 7 * 86400) {
382 		(void)strftime(buf, sizeof(buf) - 1,
383 		use_ampm ? "%a%I%p" : "%a%H  ", tp);
384 	} else
385 		(void)strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
386 	(void)printf("%-*s", v->width, buf);
387 }
388 
389 void
390 lstarted(k, ve)
391 	KINFO *k;
392 	VARENT *ve;
393 {
394 	VAR *v;
395 	time_t then;
396 	char buf[100];
397 
398 	v = ve->var;
399 	if (!k->ki_u.u_valid) {
400 		(void)printf("%-*s", v->width, "-");
401 		return;
402 	}
403 	then = k->ki_u.u_start.tv_sec;
404 	(void)strftime(buf, sizeof(buf) -1, "%c", localtime(&then));
405 	(void)printf("%-*s", v->width, buf);
406 }
407 
408 void
409 wchan(k, ve)
410 	KINFO *k;
411 	VARENT *ve;
412 {
413 	VAR *v;
414 
415 	v = ve->var;
416 	if (KI_THREAD(k)->td_wchan) {
417 		if (KI_THREAD(k)->td_wmesg)
418 			(void)printf("%-*.*s", v->width, v->width,
419 				      KI_EPROC(k)->e_wmesg);
420 		else
421 			(void)printf("%-*lx", v->width,
422 			    (long)KI_THREAD(k)->td_wchan);
423 	} else
424 		(void)printf("%-*s", v->width, "-");
425 }
426 
427 #ifndef pgtok
428 #define pgtok(a)        (((a)*getpagesize())/1024)
429 #endif
430 
431 void
432 vsize(k, ve)
433 	KINFO *k;
434 	VARENT *ve;
435 {
436 	VAR *v;
437 
438 	v = ve->var;
439 	(void)printf("%*d", v->width,
440 	    (KI_EPROC(k)->e_vm.vm_map.size/1024));
441 }
442 
443 void
444 rssize(k, ve)
445 	KINFO *k;
446 	VARENT *ve;
447 {
448 	VAR *v;
449 
450 	v = ve->var;
451 	/* XXX don't have info about shared */
452 	(void)printf("%*lu", v->width,
453 	    (u_long)pgtok(KI_EPROC(k)->e_vm.vm_rssize));
454 }
455 
456 void
457 p_rssize(k, ve)		/* doesn't account for text */
458 	KINFO *k;
459 	VARENT *ve;
460 {
461 	VAR *v;
462 
463 	v = ve->var;
464 	(void)printf("%*ld", v->width, (long)pgtok(KI_EPROC(k)->e_vm.vm_rssize));
465 }
466 
467 void
468 cputime(k, ve)
469 	KINFO *k;
470 	VARENT *ve;
471 {
472 	VAR *v;
473 	long secs;
474 	long psecs;	/* "parts" of a second. first micro, then centi */
475 	char obuff[128];
476 	static char decimal_point = 0;
477 
478 	if (!decimal_point)
479 		decimal_point = localeconv()->decimal_point[0];
480 	v = ve->var;
481 	if (KI_PROC(k)->p_stat == SZOMB || !k->ki_u.u_valid) {
482 		secs = 0;
483 		psecs = 0;
484 	} else {
485 		u_int64_t timeus;
486 
487 		/*
488 		 * This counts time spent handling interrupts.  We could
489 		 * fix this, but it is not 100% trivial (and interrupt
490 		 * time fractions only work on the sparc anyway).	XXX
491 		 */
492 		timeus = KI_EPROC(k)->e_uticks + KI_EPROC(k)->e_sticks;
493 		secs = timeus / 1000000;
494 		psecs = timeus % 1000000;
495 		if (sumrusage) {
496 			secs += k->ki_u.u_cru.ru_utime.tv_sec +
497 				k->ki_u.u_cru.ru_stime.tv_sec;
498 			psecs += k->ki_u.u_cru.ru_utime.tv_usec +
499 				k->ki_u.u_cru.ru_stime.tv_usec;
500 		}
501 		/*
502 		 * round and scale to 100's
503 		 */
504 		psecs = (psecs + 5000) / 10000;
505 		secs += psecs / 100;
506 		psecs = psecs % 100;
507 	}
508 	(void)snprintf(obuff, sizeof(obuff),
509 	    "%3ld:%02ld%c%02ld", secs/60, secs%60, decimal_point, psecs);
510 	(void)printf("%*s", v->width, obuff);
511 }
512 
513 double
514 getpcpu(k)
515 	KINFO *k;
516 {
517 	struct proc *p;
518 	static int failure;
519 
520 	if (!nlistread)
521 		failure = donlist();
522 	if (failure)
523 		return (0.0);
524 
525 	p = KI_PROC(k);
526 #define	fxtofl(fixpt)	((double)(fixpt) / fscale)
527 
528 	/* XXX - I don't like this */
529 	if (p->p_swtime == 0 || (p->p_flag & P_INMEM) == 0)
530 		return (0.0);
531 	if (rawcpu)
532 		return (100.0 * fxtofl(p->p_pctcpu));
533 	return (100.0 * fxtofl(p->p_pctcpu) /
534 		(1.0 - exp(p->p_swtime * log(fxtofl(ccpu)))));
535 }
536 
537 void
538 pcpu(k, ve)
539 	KINFO *k;
540 	VARENT *ve;
541 {
542 	VAR *v;
543 
544 	v = ve->var;
545 	(void)printf("%*.1f", v->width, getpcpu(k));
546 }
547 
548 void
549 pnice(k, ve)
550 	KINFO *k;
551 	VARENT *ve;
552 {
553 	VAR *v;
554 	int nice;
555 
556 	switch (KI_PROC(k)->p_rtprio.type) {
557 	case RTP_PRIO_REALTIME:
558 		nice = PRIO_MIN - 1 - RTP_PRIO_MAX + KI_PROC(k)->p_rtprio.prio;
559 		break;
560 	case RTP_PRIO_IDLE:
561 		nice = PRIO_MAX + 1 + KI_PROC(k)->p_rtprio.prio;
562 		break;
563 	case RTP_PRIO_THREAD:
564 		nice = PRIO_MIN - 1 - RTP_PRIO_MAX - KI_PROC(k)->p_rtprio.prio;
565 		break;
566 	default:
567 		nice = KI_PROC(k)->p_nice - NZERO;
568 		break;
569 	}
570 	v = ve->var;
571 	(void)printf("%*d", v->width, nice);
572 }
573 
574 
575 double
576 getpmem(k)
577 	KINFO *k;
578 {
579 	static int failure;
580 	struct proc *p;
581 	struct eproc *e;
582 	double fracmem;
583 	int szptudot;
584 
585 	if (!nlistread)
586 		failure = donlist();
587 	if (failure)
588 		return (0.0);
589 
590 	p = KI_PROC(k);
591 	e = KI_EPROC(k);
592 	if ((p->p_flag & P_INMEM) == 0)
593 		return (0.0);
594 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
595 	szptudot = UPAGES;
596 	/* XXX don't have info about shared */
597 	fracmem = ((float)e->e_vm.vm_rssize + szptudot)/mempages;
598 	return (100.0 * fracmem);
599 }
600 
601 void
602 pmem(k, ve)
603 	KINFO *k;
604 	VARENT *ve;
605 {
606 	VAR *v;
607 
608 	v = ve->var;
609 	(void)printf("%*.1f", v->width, getpmem(k));
610 }
611 
612 void
613 pagein(k, ve)
614 	KINFO *k;
615 	VARENT *ve;
616 {
617 	VAR *v;
618 
619 	v = ve->var;
620 	(void)printf("%*ld", v->width,
621 	    k->ki_u.u_valid ? k->ki_u.u_ru.ru_majflt : 0);
622 }
623 
624 void
625 maxrss(k, ve)
626 	KINFO *k;
627 	VARENT *ve;
628 {
629 	VAR *v;
630 
631 	v = ve->var;
632 	/* XXX not yet */
633 	(void)printf("%*s", v->width, "-");
634 }
635 
636 void
637 tsize(k, ve)
638 	KINFO *k;
639 	VARENT *ve;
640 {
641 	VAR *v;
642 
643 	v = ve->var;
644 	(void)printf("%*ld", v->width, (long)pgtok(KI_EPROC(k)->e_vm.vm_tsize));
645 }
646 
647 void
648 rtprior(k, ve)
649 	KINFO *k;
650 	VARENT *ve;
651 {
652 	VAR *v;
653 	struct rtprio *prtp;
654 	char str[8];
655 	unsigned prio, type;
656 
657 	v = ve->var;
658 	prtp = (struct rtprio *) ((char *)KI_PROC(k) + v->off);
659 	prio = prtp->prio;
660 	type = prtp->type;
661 	switch (type) {
662 	case RTP_PRIO_REALTIME:
663 		snprintf(str, sizeof(str), "real:%u", prio);
664 		break;
665 	case RTP_PRIO_NORMAL:
666 		strncpy(str, "normal", sizeof(str));
667 		break;
668 	case RTP_PRIO_IDLE:
669 		snprintf(str, sizeof(str), "idle:%u", prio);
670 		break;
671 	default:
672 		snprintf(str, sizeof(str), "%u:%u", type, prio);
673 		break;
674 	}
675 	str[sizeof(str) - 1] = '\0';
676 	(void)printf("%*s", v->width, str);
677 }
678 
679 /*
680  * Generic output routines.  Print fields from various prototype
681  * structures.
682  */
683 static void
684 printval(bp, v)
685 	char *bp;
686 	VAR *v;
687 {
688 	static char ofmt[32] = "%";
689 	char *fcp, *cp;
690 
691 	cp = ofmt + 1;
692 	fcp = v->fmt;
693 	if (v->flag & LJUST)
694 		*cp++ = '-';
695 	*cp++ = '*';
696 	while ((*cp++ = *fcp++));
697 
698 	switch (v->type) {
699 	case CHAR:
700 		(void)printf(ofmt, v->width, *(char *)bp);
701 		break;
702 	case UCHAR:
703 		(void)printf(ofmt, v->width, *(u_char *)bp);
704 		break;
705 	case SHORT:
706 		(void)printf(ofmt, v->width, *(short *)bp);
707 		break;
708 	case USHORT:
709 		(void)printf(ofmt, v->width, *(u_short *)bp);
710 		break;
711 	case INT:
712 		(void)printf(ofmt, v->width, *(int *)bp);
713 		break;
714 	case UINT:
715 		(void)printf(ofmt, v->width, *(u_int *)bp);
716 		break;
717 	case LONG:
718 		(void)printf(ofmt, v->width, *(long *)bp);
719 		break;
720 	case ULONG:
721 		(void)printf(ofmt, v->width, *(u_long *)bp);
722 		break;
723 	case KPTR:
724 		(void)printf(ofmt, v->width, *(u_long *)bp);
725 		break;
726 	default:
727 		errx(1, "unknown type %d", v->type);
728 	}
729 }
730 
731 void
732 pvar(k, ve)
733 	KINFO *k;
734 	VARENT *ve;
735 {
736 	VAR *v;
737 
738 	v = ve->var;
739 	printval((char *)((char *)KI_PROC(k) + v->off), v);
740 }
741 
742 void
743 tvar(k, ve)
744 	KINFO *k;
745 	VARENT *ve;
746 {
747 	VAR *v;
748 
749 	v = ve->var;
750 	printval((char *)((char *)KI_THREAD(k) + v->off), v);
751 }
752 
753 void
754 evar(k, ve)
755 	KINFO *k;
756 	VARENT *ve;
757 {
758 	VAR *v;
759 
760 	v = ve->var;
761 	printval((char *)((char *)KI_EPROC(k) + v->off), v);
762 }
763 
764 void
765 uvar(k, ve)
766 	KINFO *k;
767 	VARENT *ve;
768 {
769 	VAR *v;
770 
771 	v = ve->var;
772 	if (k->ki_u.u_valid)
773 		printval((char *)((char *)&k->ki_u + v->off), v);
774 	else
775 		(void)printf("%*s", v->width, "-");
776 }
777 
778 void
779 rvar(k, ve)
780 	KINFO *k;
781 	VARENT *ve;
782 {
783 	VAR *v;
784 
785 	v = ve->var;
786 	if (k->ki_u.u_valid)
787 		printval((char *)((char *)(&k->ki_u.u_ru) + v->off), v);
788 	else
789 		(void)printf("%*s", v->width, "-");
790 }
791