Home | History | Annotate | Line # | Download | only in ps
print.c revision 1.16 
      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 
     34 #ifndef lint
     35 static char sccsid[] = "@(#)print.c	8.6 (Berkeley) 4/16/94";
     36 #endif /* not lint */
     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 #ifdef P_PPWAIT
     45 #define NEWVM
     46 #endif
     47 
     48 #ifdef NEWVM
     49 #include <sys/ucred.h>
     50 #include <sys/sysctl.h>
     51 #include <vm/vm.h>
     52 #else
     53 #include <machine/pte.h>
     54 #include <sys/vmparam.h>
     55 #include <sys/vm.h>
     56 #endif
     57 
     58 #include <err.h>
     59 #include <math.h>
     60 #include <nlist.h>
     61 #include <stddef.h>
     62 #include <stdio.h>
     63 #include <stdlib.h>
     64 #include <string.h>
     65 #include <vis.h>
     66 #include <tzfile.h>
     67 #include <unistd.h>
     68 
     69 #include "ps.h"
     70 
     71 void
     72 printheader()
     73 {
     74 	VAR *v;
     75 	struct varent *vent;
     76 
     77 	for (vent = vhead; vent; vent = vent->next) {
     78 		v = vent->var;
     79 		if (v->flag & LJUST) {
     80 			if (vent->next == NULL)	/* last one */
     81 				(void)printf("%s", v->header);
     82 			else
     83 				(void)printf("%-*s", v->width, v->header);
     84 		} else
     85 			(void)printf("%*s", v->width, v->header);
     86 		if (vent->next != NULL)
     87 			(void)putchar(' ');
     88 	}
     89 	(void)putchar('\n');
     90 }
     91 
     92 void
     93 command(k, ve)
     94 	KINFO *k;
     95 	VARENT *ve;
     96 {
     97 	VAR *v;
     98 	int left;
     99 	char *cp, *vis_env, *vis_args;
    100 
    101 	if ((vis_args = malloc(strlen(k->ki_args) * 4 + 1)) == NULL)
    102 		err(1, NULL);
    103 	strvis(vis_args, k->ki_args, VIS_TAB | VIS_NL | VIS_NOSLASH);
    104 	if (k->ki_env) {
    105 		if ((vis_env = malloc(strlen(k->ki_env) * 4 + 1)) == NULL)
    106 			err(1, NULL);
    107 		strvis(vis_env, k->ki_env, VIS_TAB | VIS_NL | VIS_NOSLASH);
    108 	} else
    109 		vis_env = NULL;
    110 
    111 	v = ve->var;
    112 	if (ve->next == NULL) {
    113 		/* last field */
    114 		if (termwidth == UNLIMITED) {
    115 			if (vis_env)
    116 				(void)printf("%s ", vis_env);
    117 			(void)printf("%s", vis_args);
    118 		} else {
    119 			left = termwidth - (totwidth - v->width);
    120 			if (left < 1) /* already wrapped, just use std width */
    121 				left = v->width;
    122 			if ((cp = vis_env) != NULL) {
    123 				while (--left >= 0 && *cp)
    124 					(void)putchar(*cp++);
    125 				if (--left >= 0)
    126 					putchar(' ');
    127 			}
    128 			for (cp = vis_args; --left >= 0 && *cp != '\0';)
    129 				(void)putchar(*cp++);
    130 		}
    131 	} else
    132 		/* XXX env? */
    133 		(void)printf("%-*.*s", v->width, v->width, vis_args);
    134 	free(vis_args);
    135 	if (vis_env != NULL)
    136 		free(vis_env);
    137 }
    138 
    139 void
    140 ucomm(k, ve)
    141 	KINFO *k;
    142 	VARENT *ve;
    143 {
    144 	VAR *v;
    145 
    146 	v = ve->var;
    147 	(void)printf("%-*s", v->width, KI_PROC(k)->p_comm);
    148 }
    149 
    150 void
    151 logname(k, ve)
    152 	KINFO *k;
    153 	VARENT *ve;
    154 {
    155 	VAR *v;
    156 
    157 	v = ve->var;
    158 #ifndef NEWVM
    159 	(void)printf("%-*s", v->width, KI_PROC(k)->p_logname);
    160 #else
    161 	(void)printf("%-*s", v->width, KI_EPROC(k)->e_login);
    162 #endif
    163 }
    164 
    165 void
    166 state(k, ve)
    167 	KINFO *k;
    168 	VARENT *ve;
    169 {
    170 	struct proc *p;
    171 	int flag;
    172 	char *cp;
    173 	VAR *v;
    174 	char buf[16];
    175 
    176 	v = ve->var;
    177 	p = KI_PROC(k);
    178 	flag = p->p_flag;
    179 	cp = buf;
    180 
    181 	switch (p->p_stat) {
    182 
    183 	case SSTOP:
    184 		*cp = 'T';
    185 		break;
    186 
    187 	case SSLEEP:
    188 		if (flag & P_SINTR)	/* interuptable (long) */
    189 			*cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
    190 		else
    191 			*cp = 'D';
    192 		break;
    193 
    194 	case SRUN:
    195 	case SIDL:
    196 		*cp = 'R';
    197 		break;
    198 
    199 	case SZOMB:
    200 		*cp = 'Z';
    201 		break;
    202 
    203 	default:
    204 		*cp = '?';
    205 	}
    206 	cp++;
    207 	if (flag & P_INMEM) {
    208 #ifndef NEWVM
    209 		if (p->p_rssize > p->p_maxrss)
    210 			*cp++ = '>';
    211 #endif
    212 	} else
    213 		*cp++ = 'W';
    214 	if (p->p_nice < NZERO)
    215 		*cp++ = '<';
    216 	else if (p->p_nice > NZERO)
    217 		*cp++ = 'N';
    218 #ifndef NEWVM
    219 	if (flag & SUANOM)
    220 		*cp++ = 'A';
    221 	else if (flag & SSEQL)
    222 		*cp++ = 'S';
    223 #endif
    224 	if (flag & P_TRACED)
    225 		*cp++ = 'X';
    226 	if (flag & P_WEXIT && p->p_stat != SZOMB)
    227 		*cp++ = 'E';
    228 #ifdef NEWVM
    229 	if (flag & P_PPWAIT)
    230 #else
    231 	if (flag & SVFORK)
    232 #endif
    233 		*cp++ = 'V';
    234 #ifdef NEWVM
    235 	if ((flag & P_SYSTEM) || p->p_holdcnt)
    236 #else
    237 	if (flag & (SSYS|SLOCK|SULOCK|SKEEP|SPHYSIO))
    238 #endif
    239 		*cp++ = 'L';
    240 	if (KI_EPROC(k)->e_flag & EPROC_SLEADER)
    241 		*cp++ = 's';
    242 	if ((flag & P_CONTROLT) && KI_EPROC(k)->e_pgid == KI_EPROC(k)->e_tpgid)
    243 		*cp++ = '+';
    244 	*cp = '\0';
    245 	(void)printf("%-*s", v->width, buf);
    246 }
    247 
    248 void
    249 pri(k, ve)
    250 	KINFO *k;
    251 	VARENT *ve;
    252 {
    253 	VAR *v;
    254 
    255 	v = ve->var;
    256 	(void)printf("%*d", v->width, KI_PROC(k)->p_priority - PZERO);
    257 }
    258 
    259 void
    260 uname(k, ve)
    261 	KINFO *k;
    262 	VARENT *ve;
    263 {
    264 	VAR *v;
    265 
    266 	v = ve->var;
    267 #ifndef NEWVM
    268 	(void)printf("%-*s",
    269 	    (int)v->width, user_from_uid(KI_PROC(k)->p_uid, 0));
    270 #else
    271 	(void)printf("%-*s",
    272 	    (int)v->width, user_from_uid(KI_EPROC(k)->e_ucred.cr_uid, 0));
    273 #endif
    274 }
    275 
    276 void
    277 runame(k, ve)
    278 	KINFO *k;
    279 	VARENT *ve;
    280 {
    281 	VAR *v;
    282 
    283 	v = ve->var;
    284 #ifndef NEWVM
    285 	(void)printf("%-*s",
    286 	    (int)v->width, user_from_uid(KI_PROC(k)->p_ruid, 0));
    287 #else
    288 	(void)printf("%-*s",
    289 	    (int)v->width, user_from_uid(KI_EPROC(k)->e_pcred.p_ruid, 0));
    290 #endif
    291 }
    292 
    293 void
    294 tdev(k, ve)
    295 	KINFO *k;
    296 	VARENT *ve;
    297 {
    298 	VAR *v;
    299 	dev_t dev;
    300 	char buff[16];
    301 
    302 	v = ve->var;
    303 	dev = KI_EPROC(k)->e_tdev;
    304 	if (dev == NODEV)
    305 		(void)printf("%*s", v->width, "??");
    306 	else {
    307 		(void)snprintf(buff, sizeof(buff),
    308 		    "%d/%d", major(dev), minor(dev));
    309 		(void)printf("%*s", v->width, buff);
    310 	}
    311 }
    312 
    313 void
    314 tname(k, ve)
    315 	KINFO *k;
    316 	VARENT *ve;
    317 {
    318 	VAR *v;
    319 	dev_t dev;
    320 	char *ttname;
    321 
    322 	v = ve->var;
    323 	dev = KI_EPROC(k)->e_tdev;
    324 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
    325 		(void)printf("%-*s", v->width, "??");
    326 	else {
    327 		if (strncmp(ttname, "tty", 3) == 0)
    328 			ttname += 3;
    329 		(void)printf("%*.*s%c", v->width-1, v->width-1, ttname,
    330 			KI_EPROC(k)->e_flag & EPROC_CTTY ? ' ' : '-');
    331 	}
    332 }
    333 
    334 void
    335 longtname(k, ve)
    336 	KINFO *k;
    337 	VARENT *ve;
    338 {
    339 	VAR *v;
    340 	dev_t dev;
    341 	char *ttname;
    342 
    343 	v = ve->var;
    344 	dev = KI_EPROC(k)->e_tdev;
    345 	if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
    346 		(void)printf("%-*s", v->width, "??");
    347 	else
    348 		(void)printf("%-*s", v->width, ttname);
    349 }
    350 
    351 void
    352 started(k, ve)
    353 	KINFO *k;
    354 	VARENT *ve;
    355 {
    356 	VAR *v;
    357 	static time_t now;
    358 	struct tm *tp;
    359 	char buf[100];
    360 
    361 	v = ve->var;
    362 	if (!k->ki_u.u_valid) {
    363 		(void)printf("%-*s", v->width, "-");
    364 		return;
    365 	}
    366 
    367 	tp = localtime(&k->ki_u.u_start.tv_sec);
    368 	if (!now)
    369 		(void)time(&now);
    370 	if (now - k->ki_u.u_start.tv_sec < 24 * SECSPERHOUR) {
    371 		/* I *hate* SCCS... */
    372 		static char fmt[] = __CONCAT("%l:%", "M%p");
    373 		(void)strftime(buf, sizeof(buf) - 1, fmt, tp);
    374 	} else if (now - k->ki_u.u_start.tv_sec < 7 * SECSPERDAY) {
    375 		/* I *hate* SCCS... */
    376 		static char fmt[] = __CONCAT("%a%", "I%p");
    377 		(void)strftime(buf, sizeof(buf) - 1, fmt, tp);
    378 	} else
    379 		(void)strftime(buf, sizeof(buf) - 1, "%e%b%y", tp);
    380 	(void)printf("%-*s", v->width, buf);
    381 }
    382 
    383 void
    384 lstarted(k, ve)
    385 	KINFO *k;
    386 	VARENT *ve;
    387 {
    388 	VAR *v;
    389 	char buf[100];
    390 
    391 	v = ve->var;
    392 	if (!k->ki_u.u_valid) {
    393 		(void)printf("%-*s", v->width, "-");
    394 		return;
    395 	}
    396 	(void)strftime(buf, sizeof(buf) -1, "%C",
    397 	    localtime(&k->ki_u.u_start.tv_sec));
    398 	(void)printf("%-*s", v->width, buf);
    399 }
    400 
    401 void
    402 wchan(k, ve)
    403 	KINFO *k;
    404 	VARENT *ve;
    405 {
    406 	VAR *v;
    407 
    408 	v = ve->var;
    409 	if (KI_PROC(k)->p_wchan) {
    410 		if (KI_PROC(k)->p_wmesg)
    411 			(void)printf("%-*.*s", v->width, v->width,
    412 				      KI_EPROC(k)->e_wmesg);
    413 		else
    414 			(void)printf("%-*x", v->width,
    415 			    (int)KI_PROC(k)->p_wchan &~ KERNBASE);
    416 	} else
    417 		(void)printf("%-*s", v->width, "-");
    418 }
    419 
    420 #define pgtok(a)        (((a)*getpagesize())/1024)
    421 
    422 void
    423 vsize(k, ve)
    424 	KINFO *k;
    425 	VARENT *ve;
    426 {
    427 	VAR *v;
    428 
    429 	v = ve->var;
    430 	(void)printf("%*d", v->width,
    431 #ifndef NEWVM
    432 	    pgtok(KI_PROC(k)->p_dsize +
    433 	        KI_PROC(k)->p_ssize + KI_EPROC(k)->e_xsize));
    434 #else
    435 	    pgtok(KI_EPROC(k)->e_vm.vm_dsize + KI_EPROC(k)->e_vm.vm_ssize +
    436 		KI_EPROC(k)->e_vm.vm_tsize));
    437 #endif
    438 }
    439 
    440 void
    441 rssize(k, ve)
    442 	KINFO *k;
    443 	VARENT *ve;
    444 {
    445 	VAR *v;
    446 
    447 	v = ve->var;
    448 #ifndef NEWVM
    449 	(void)printf("%*d", v->width,
    450 	    pgtok(KI_PROC(k)->p_rssize + (KI_EPROC(k)->e_xccount ?
    451 	    (KI_EPROC(k)->e_xrssize / KI_EPROC(k)->e_xccount) : 0)));
    452 #else
    453 	/* XXX don't have info about shared */
    454 	(void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_rssize));
    455 #endif
    456 }
    457 
    458 void
    459 p_rssize(k, ve)		/* doesn't account for text */
    460 	KINFO *k;
    461 	VARENT *ve;
    462 {
    463 	VAR *v;
    464 
    465 	v = ve->var;
    466 #ifndef NEWVM
    467 	(void)printf("%*d", v->width, pgtok(KI_PROC(k)->p_rssize));
    468 #else
    469 	(void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_rssize));
    470 #endif
    471 }
    472 
    473 void
    474 cputime(k, ve)
    475 	KINFO *k;
    476 	VARENT *ve;
    477 {
    478 	VAR *v;
    479 	long secs;
    480 	long psecs;	/* "parts" of a second. first micro, then centi */
    481 	char obuff[128];
    482 
    483 	v = ve->var;
    484 	if (KI_PROC(k)->p_stat == SZOMB || !k->ki_u.u_valid) {
    485 		secs = 0;
    486 		psecs = 0;
    487 	} else {
    488 		/*
    489 		 * This counts time spent handling interrupts.  We could
    490 		 * fix this, but it is not 100% trivial (and interrupt
    491 		 * time fractions only work on the sparc anyway).	XXX
    492 		 */
    493 		secs = KI_PROC(k)->p_rtime.tv_sec;
    494 		psecs = KI_PROC(k)->p_rtime.tv_usec;
    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.%02ld", secs/60, secs%60, 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 double
    549 getpmem(k)
    550 	KINFO *k;
    551 {
    552 	static int failure;
    553 	struct proc *p;
    554 	struct eproc *e;
    555 	double fracmem;
    556 	int szptudot;
    557 
    558 	if (!nlistread)
    559 		failure = donlist();
    560 	if (failure)
    561 		return (0.0);
    562 
    563 	p = KI_PROC(k);
    564 	e = KI_EPROC(k);
    565 	if ((p->p_flag & P_INMEM) == 0)
    566 		return (0.0);
    567 #ifndef NEWVM
    568 	szptudot = USPACE/getpagesize() +
    569 	    clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
    570 	fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/mempages;
    571 	if (p->p_textp && e->e_xccount)
    572 		fracmem += ((float)e->e_xrssize)/CLSIZE/e->e_xccount/mempages;
    573 #else
    574 	/* XXX want pmap ptpages, segtab, etc. (per architecture) */
    575 	szptudot = USPACE/getpagesize();
    576 	/* XXX don't have info about shared */
    577 	fracmem = ((float)e->e_vm.vm_rssize + szptudot)/CLSIZE/mempages;
    578 #endif
    579 	return (100.0 * fracmem);
    580 }
    581 
    582 void
    583 pmem(k, ve)
    584 	KINFO *k;
    585 	VARENT *ve;
    586 {
    587 	VAR *v;
    588 
    589 	v = ve->var;
    590 	(void)printf("%*.1f", v->width, getpmem(k));
    591 }
    592 
    593 void
    594 pagein(k, ve)
    595 	KINFO *k;
    596 	VARENT *ve;
    597 {
    598 	VAR *v;
    599 
    600 	v = ve->var;
    601 	(void)printf("%*d", v->width,
    602 	    k->ki_u.u_valid ? k->ki_u.u_ru.ru_majflt : 0);
    603 }
    604 
    605 void
    606 maxrss(k, ve)
    607 	KINFO *k;
    608 	VARENT *ve;
    609 {
    610 	VAR *v;
    611 
    612 	v = ve->var;
    613 #ifndef NEWVM	/* not yet */
    614 	if (KI_PROC(k)->p_maxrss != (RLIM_INFINITY/getpagesize()))
    615 		(void)printf("%*d", v->width, pgtok(KI_PROC(k)->p_maxrss));
    616 	else
    617 #endif
    618 		(void)printf("%*s", v->width, "-");
    619 }
    620 
    621 void
    622 tsize(k, ve)
    623 	KINFO *k;
    624 	VARENT *ve;
    625 {
    626 	VAR *v;
    627 
    628 	v = ve->var;
    629 #ifndef NEWVM
    630 	(void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_xsize));
    631 #else
    632 	(void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_vm.vm_tsize));
    633 #endif
    634 }
    635 
    636 #ifndef NEWVM
    637 void
    638 trss(k, ve)
    639 	KINFO *k;
    640 	VARENT *ve;
    641 {
    642 	VAR *v;
    643 
    644 	v = ve->var;
    645 	(void)printf("%*d", v->width, pgtok(KI_EPROC(k)->e_xrssize));
    646 }
    647 #endif
    648 
    649 /*
    650  * Generic output routines.  Print fields from various prototype
    651  * structures.
    652  */
    653 static void
    654 printval(bp, v)
    655 	char *bp;
    656 	VAR *v;
    657 {
    658 	static char ofmt[32] = "%";
    659 	char *fcp, *cp;
    660 
    661 	cp = ofmt + 1;
    662 	fcp = v->fmt;
    663 	if (v->flag & LJUST)
    664 		*cp++ = '-';
    665 	*cp++ = '*';
    666 	while (*cp++ = *fcp++);
    667 
    668 	switch (v->type) {
    669 	case CHAR:
    670 		(void)printf(ofmt, v->width, *(char *)bp);
    671 		break;
    672 	case UCHAR:
    673 		(void)printf(ofmt, v->width, *(u_char *)bp);
    674 		break;
    675 	case SHORT:
    676 		(void)printf(ofmt, v->width, *(short *)bp);
    677 		break;
    678 	case USHORT:
    679 		(void)printf(ofmt, v->width, *(u_short *)bp);
    680 		break;
    681 	case LONG:
    682 		(void)printf(ofmt, v->width, *(long *)bp);
    683 		break;
    684 	case ULONG:
    685 		(void)printf(ofmt, v->width, *(u_long *)bp);
    686 		break;
    687 	case KPTR:
    688 		(void)printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
    689 		break;
    690 	default:
    691 		errx(1, "unknown type %d", v->type);
    692 	}
    693 }
    694 
    695 void
    696 pvar(k, ve)
    697 	KINFO *k;
    698 	VARENT *ve;
    699 {
    700 	VAR *v;
    701 
    702 	v = ve->var;
    703 	printval((char *)((char *)KI_PROC(k) + v->off), v);
    704 }
    705 
    706 void
    707 evar(k, ve)
    708 	KINFO *k;
    709 	VARENT *ve;
    710 {
    711 	VAR *v;
    712 
    713 	v = ve->var;
    714 	printval((char *)((char *)KI_EPROC(k) + v->off), v);
    715 }
    716 
    717 void
    718 uvar(k, ve)
    719 	KINFO *k;
    720 	VARENT *ve;
    721 {
    722 	VAR *v;
    723 
    724 	v = ve->var;
    725 	if (k->ki_u.u_valid)
    726 		printval((char *)((char *)&k->ki_u + v->off), v);
    727 	else
    728 		(void)printf("%*s", v->width, "-");
    729 }
    730 
    731 void
    732 rvar(k, ve)
    733 	KINFO *k;
    734 	VARENT *ve;
    735 {
    736 	VAR *v;
    737 
    738 	v = ve->var;
    739 	if (k->ki_u.u_valid)
    740 		printval((char *)((char *)(&k->ki_u.u_ru) + v->off), v);
    741 	else
    742 		(void)printf("%*s", v->width, "-");
    743 }
    744