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