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