bin/ps/print.c

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