1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2007, 2011 Robert N. M. Watson
5 * Copyright (c) 2015 Allan Jude <allanjude@freebsd.org>
6 * Copyright (c) 2017 Dell EMC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <sys/param.h>
32 #include <sys/sysctl.h>
33 #include <sys/user.h>
34
35 #include <err.h>
36 #include <libprocstat.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sysexits.h>
41 #include <unistd.h>
42
43 #include "procstat.h"
44
45 enum {
46 PS_CMP_NORMAL = 0x00,
47 PS_CMP_PLURAL = 0x01,
48 PS_CMP_SUBSTR = 0x02
49 };
50
51 struct procstat_cmd {
52 const char *command;
53 const char *xocontainer;
54 const char *usage;
55 void (*cmd)(struct procstat *, struct kinfo_proc *);
56 void (*opt)(int, char * const *);
57 int cmp;
58 };
59
60 int procstat_opts = 0;
61
62 static void cmdopt_none(int argc, char * const argv[]);
63 static void cmdopt_verbose(int argc, char * const argv[]);
64 static void cmdopt_signals(int argc, char * const argv[]);
65 static void cmdopt_rusage(int argc, char * const argv[]);
66 static void cmdopt_files(int argc, char * const argv[]);
67 static void cmdopt_cpuset(int argc, char * const argv[]);
68
69 static const char *progname;
70
71 /* aliased program parameters and arguments
72 * - usage field is abused to hold the pointer to the function
73 * displaying program usage
74 */
75 static const struct procstat_cmd pacmd_table[] = {
76 /* arguments are the same as for pwdx: pid or core file */
77 { "pargs", "args", NULL, &procstat_pargs, &cmdopt_none,
78 PS_CMP_NORMAL | PS_MODE_COMPAT },
79 { "penv", "env", NULL, &procstat_penv, &cmdopt_none,
80 PS_CMP_NORMAL | PS_MODE_COMPAT },
81 { "pwdx", "pwd", NULL, &procstat_pwdx, &cmdopt_none,
82 PS_CMP_NORMAL | PS_MODE_COMPAT }
83 };
84
85 /* procstat parameters and arguments */
86 static const struct procstat_cmd cmd_table[] = {
87 { "advlock", "advisory_locks", NULL, &procstat_advlocks, &cmdopt_none,
88 PS_CMP_PLURAL | PS_CMP_SUBSTR | PS_MODE_NO_KINFO_PROC },
89 { "argument", "arguments", NULL, &procstat_args, &cmdopt_none,
90 PS_CMP_PLURAL | PS_CMP_SUBSTR },
91 { "auxv", "auxv", NULL, &procstat_auxv, &cmdopt_none, PS_CMP_NORMAL },
92 { "basic", "basic", NULL, &procstat_basic, &cmdopt_none,
93 PS_CMP_NORMAL },
94 { "binary", "binary", NULL, &procstat_bin, &cmdopt_none,
95 PS_CMP_SUBSTR },
96 { "cpuset", "cs", NULL, &procstat_cs, &cmdopt_cpuset, PS_CMP_NORMAL },
97 { "cs", "cs", NULL, &procstat_cs, &cmdopt_cpuset, PS_CMP_NORMAL },
98 { "credential", "credentials", NULL, &procstat_cred, &cmdopt_none,
99 PS_CMP_PLURAL | PS_CMP_SUBSTR },
100 { "environment", "environment", NULL, &procstat_env, &cmdopt_none,
101 PS_CMP_SUBSTR },
102 { "fd", "files", "[-C]", &procstat_files, &cmdopt_files,
103 PS_CMP_PLURAL },
104 { "file", "files", "[-C]", &procstat_files, &cmdopt_files,
105 PS_CMP_PLURAL },
106 { "kstack", "kstack", "[-v]", &procstat_kstack, &cmdopt_verbose,
107 PS_CMP_NORMAL },
108 { "pargs", "args", NULL, &procstat_pargs, &cmdopt_none,
109 PS_CMP_NORMAL },
110 { "penv", "env", NULL, &procstat_penv, &cmdopt_none,
111 PS_CMP_NORMAL },
112 { "ptlwpinfo", "ptlwpinfo", NULL, &procstat_ptlwpinfo, &cmdopt_none,
113 PS_CMP_NORMAL },
114 { "pwdx", "pwd", NULL, &procstat_pwdx, &cmdopt_none,
115 PS_CMP_NORMAL },
116 { "rlimit", "rlimit", NULL, &procstat_rlimit, &cmdopt_none,
117 PS_CMP_NORMAL },
118 { "rusage", "rusage", "[-Ht]", &procstat_rusage, &cmdopt_rusage,
119 PS_CMP_NORMAL },
120 { "sigfastblock", "sigfastblock", NULL, &procstat_sigfastblock,
121 &cmdopt_none, PS_CMP_NORMAL },
122 { "signal", "signals", "[-n]", &procstat_sigs, &cmdopt_signals,
123 PS_CMP_PLURAL | PS_CMP_SUBSTR },
124 { "thread", "threads", NULL, &procstat_threads, &cmdopt_none,
125 PS_CMP_PLURAL },
126 { "tsignal", "thread_signals", "[-n]", &procstat_threads_sigs,
127 &cmdopt_signals, PS_CMP_PLURAL | PS_CMP_SUBSTR },
128 { "vm", "vm", NULL, &procstat_vm, &cmdopt_none, PS_CMP_NORMAL }
129 };
130
131 static void
usage(const struct procstat_cmd * cmd)132 usage(const struct procstat_cmd *cmd)
133 {
134 size_t i, l;
135 int multi;
136
137 if (cmd == NULL || (cmd->cmp & PS_MODE_COMPAT) == 0) {
138 xo_error("usage: procstat [--libxo] [-h] [-M core] [-N system]"
139 " [-w interval] command\n"
140 " [pid ... | core ...]\n"
141 " procstat [--libxo] -a [-h] [-M core] [-N system] "
142 " [-w interval] command\n"
143 " procstat [--libxo] [-h] [-M core] [-N system]"
144 " [-w interval]\n"
145 " [-S | -b | -c | -e | -f [-C] | -i [-n] | "
146 "-j [-n] | -k [-k] |\n"
147 " -l | -r [-H] | -s | -t | -v | -x] "
148 "[pid ... | core ...]\n"
149 " procstat [--libxo] -a [-h] [-M core] [-N system]"
150 " [-w interval]\n"
151 " [-S | -b | -c | -e | -f [-C] | -i [-n] | "
152 "-j [-n] | -k [-k] |\n"
153 " -l | -r [-H] | -s | -t | -v | -x]\n"
154 " procstat [--libxo] -L [-h] [-M core] [-N system] core ...\n"
155 "Available commands:\n");
156 for (i = 0, l = nitems(cmd_table); i < l; i++) {
157 multi = i + 1 < l && cmd_table[i].cmd ==
158 cmd_table[i + 1].cmd;
159 xo_error(" %s%s%s", multi ? "[" : "",
160 cmd_table[i].command, (cmd_table[i].cmp &
161 PS_CMP_PLURAL) ? "(s)" : "");
162 for (; i + 1 < l && cmd_table[i].cmd ==
163 cmd_table[i + 1].cmd; i++)
164 xo_error(" | %s%s", cmd_table[i + 1].command,
165 (cmd_table[i].cmp & PS_CMP_PLURAL) ?
166 "(s)" : "");
167 if (multi)
168 xo_error("]");
169 if (cmd_table[i].usage != NULL)
170 xo_error(" %s", cmd_table[i].usage);
171 xo_error("\n");
172 }
173 } else {
174 xo_error("usage: %s [--libxo] pid ...\n", progname);
175 }
176 xo_finish();
177 exit(EX_USAGE);
178 }
179
180 static void
procstat(const struct procstat_cmd * cmd,struct procstat * prstat,struct kinfo_proc * kipp)181 procstat(const struct procstat_cmd *cmd, struct procstat *prstat,
182 struct kinfo_proc *kipp)
183 {
184 char *pidstr = NULL;
185
186 asprintf(&pidstr, "%d", kipp->ki_pid);
187 if (pidstr == NULL)
188 xo_errc(1, ENOMEM, "Failed to allocate memory in procstat()");
189 xo_open_container(pidstr);
190 cmd->cmd(prstat, kipp);
191 xo_close_container(pidstr);
192 free(pidstr);
193 }
194
195 /*
196 * Sort processes first by pid and then tid.
197 */
198 static int
kinfo_proc_compare(const void * a,const void * b)199 kinfo_proc_compare(const void *a, const void *b)
200 {
201 int i;
202
203 i = ((const struct kinfo_proc *)a)->ki_pid -
204 ((const struct kinfo_proc *)b)->ki_pid;
205 if (i != 0)
206 return (i);
207 i = ((const struct kinfo_proc *)a)->ki_tid -
208 ((const struct kinfo_proc *)b)->ki_tid;
209 return (i);
210 }
211
212 void
kinfo_proc_sort(struct kinfo_proc * kipp,int count)213 kinfo_proc_sort(struct kinfo_proc *kipp, int count)
214 {
215
216 qsort(kipp, count, sizeof(*kipp), kinfo_proc_compare);
217 }
218
219 const char *
kinfo_proc_thread_name(const struct kinfo_proc * kipp)220 kinfo_proc_thread_name(const struct kinfo_proc *kipp)
221 {
222 static char name[MAXCOMLEN+1];
223
224 strlcpy(name, kipp->ki_tdname, sizeof(name));
225 strlcat(name, kipp->ki_moretdname, sizeof(name));
226 if (name[0] == '\0' || strcmp(kipp->ki_comm, name) == 0) {
227 name[0] = '-';
228 name[1] = '\0';
229 }
230
231 return (name);
232 }
233
234 static const struct procstat_cmd *
getcmdbyprogname(const char * pprogname)235 getcmdbyprogname(const char *pprogname)
236 {
237 const char *ca;
238 size_t i;
239
240 if (pprogname == NULL)
241 return (NULL);
242
243 for (i = 0; i < nitems(pacmd_table); i++) {
244 ca = pacmd_table[i].command;
245 if (ca != NULL && strcmp(ca, pprogname) == 0)
246 return (&pacmd_table[i]);
247 }
248
249 return (NULL);
250 }
251
252 static const struct procstat_cmd *
getcmd(const char * str)253 getcmd(const char *str)
254 {
255 const struct procstat_cmd *cmd;
256 size_t i, l;
257 int cmp, s;
258
259 if (str == NULL)
260 return (NULL);
261 cmd = NULL;
262 if ((l = strlen(str)) == 0)
263 return (getcmd("basic"));
264 s = l > 1 && strcasecmp(str + l - 1, "s") == 0;
265 for (i = 0; i < nitems(cmd_table); i++) {
266 /*
267 * After the first match substring matches are disabled,
268 * allowing subsequent full matches to take precedence.
269 */
270 if (cmd == NULL && (cmd_table[i].cmp & PS_CMP_SUBSTR))
271 cmp = strncasecmp(str, cmd_table[i].command, l -
272 ((cmd_table[i].cmp & PS_CMP_PLURAL) && s ? 1 : 0));
273 else if ((cmd_table[i].cmp & PS_CMP_PLURAL) && s &&
274 l == strlen(cmd_table[i].command) + 1)
275 cmp = strncasecmp(str, cmd_table[i].command, l - 1);
276 else
277 cmp = strcasecmp(str, cmd_table[i].command);
278 if (cmp == 0)
279 cmd = &cmd_table[i];
280 }
281 return (cmd);
282 }
283
284 int
main(int argc,char * argv[])285 main(int argc, char *argv[])
286 {
287 struct kinfo_proc *p;
288 const struct procstat_cmd *cmd;
289 struct procstat *prstat, *cprstat;
290 char *dummy, *nlistf, *memf;
291 const char *xocontainer;
292 long l;
293 pid_t pid;
294 int aflag, ch, cnt, i, interval;
295
296 interval = 0;
297 cmd = NULL;
298 memf = nlistf = NULL;
299 aflag = 0;
300 argc = xo_parse_args(argc, argv);
301
302 progname = getprogname();
303 cmd = getcmdbyprogname(progname);
304
305 while ((ch = getopt(argc, argv, "abCcefHhijkLlM:N:nrSstvw:x")) != -1) {
306 switch (ch) {
307 case 'a':
308 aflag++;
309 break;
310 case 'b':
311 if (cmd != NULL)
312 usage(cmd);
313 cmd = getcmd("binary");
314 break;
315 case 'C':
316 procstat_opts |= PS_OPT_CAPABILITIES;
317 break;
318 case 'c':
319 if (cmd != NULL)
320 usage(cmd);
321 cmd = getcmd("arguments");
322 break;
323 case 'e':
324 if (cmd != NULL)
325 usage(cmd);
326 cmd = getcmd("environment");
327 break;
328 case 'f':
329 if (cmd != NULL)
330 usage(cmd);
331 cmd = getcmd("files");
332 break;
333 case 'H':
334 procstat_opts |= PS_OPT_PERTHREAD;
335 break;
336 case 'h':
337 procstat_opts |= PS_OPT_NOHEADER;
338 break;
339 case 'i':
340 if (cmd != NULL)
341 usage(cmd);
342 cmd = getcmd("signals");
343 break;
344 case 'j':
345 if (cmd != NULL)
346 usage(cmd);
347 cmd = getcmd("tsignals");
348 break;
349 case 'k':
350 if (cmd != NULL && cmd->cmd == procstat_kstack) {
351 if ((procstat_opts & PS_OPT_VERBOSE) != 0)
352 usage(cmd);
353 procstat_opts |= PS_OPT_VERBOSE;
354 } else {
355 if (cmd != NULL)
356 usage(cmd);
357 cmd = getcmd("kstack");
358 }
359 break;
360 case 'L':
361 if (cmd != NULL)
362 usage(cmd);
363 cmd = getcmd("ptlwpinfo");
364 break;
365 case 'l':
366 if (cmd != NULL)
367 usage(cmd);
368 cmd = getcmd("rlimit");
369 break;
370 case 'M':
371 memf = optarg;
372 break;
373 case 'N':
374 nlistf = optarg;
375 break;
376 case 'n':
377 procstat_opts |= PS_OPT_SIGNUM;
378 break;
379 case 'r':
380 if (cmd != NULL)
381 usage(cmd);
382 cmd = getcmd("rusage");
383 break;
384 case 'S':
385 if (cmd != NULL)
386 usage(cmd);
387 cmd = getcmd("cpuset");
388 break;
389 case 's':
390 if (cmd != NULL)
391 usage(cmd);
392 cmd = getcmd("credentials");
393 break;
394 case 't':
395 if (cmd != NULL)
396 usage(cmd);
397 cmd = getcmd("threads");
398 break;
399 case 'v':
400 if (cmd != NULL)
401 usage(cmd);
402 cmd = getcmd("vm");
403 break;
404 case 'w':
405 l = strtol(optarg, &dummy, 10);
406 if (*dummy != '\0')
407 usage(cmd);
408 if (l < 1 || l > INT_MAX)
409 usage(cmd);
410 interval = l;
411 break;
412 case 'x':
413 if (cmd != NULL)
414 usage(cmd);
415 cmd = getcmd("auxv");
416 break;
417 case '?':
418 default:
419 usage(cmd);
420 }
421
422 }
423 argc -= optind;
424 argv += optind;
425
426 if (cmd == NULL && argv[0] != NULL && (cmd = getcmd(argv[0])) != NULL) {
427 if ((procstat_opts & PS_SUBCOMMAND_OPTS) != 0)
428 usage(cmd);
429 if (cmd->opt != NULL) {
430 optreset = 1;
431 optind = 1;
432 cmd->opt(argc, argv);
433 if ((cmd->cmp & PS_MODE_COMPAT) == 0) {
434 argc -= optind;
435 argv += optind;
436 }
437 } else {
438 argc -= 1;
439 argv += 1;
440 }
441 } else {
442 if (cmd == NULL)
443 cmd = getcmd("basic");
444 if (cmd->cmd != procstat_files &&
445 (procstat_opts & PS_OPT_CAPABILITIES) != 0 &&
446 (cmd->cmp & PS_MODE_COMPAT) == 0)
447 usage(cmd);
448 }
449
450 /* Must specify either the -a flag or a list of pids. */
451 if (!(aflag == 1 && argc == 0) && !(aflag == 0 && argc > 0) &&
452 (cmd->cmp & PS_MODE_NO_KINFO_PROC) == 0)
453 usage(cmd);
454
455 if (memf != NULL)
456 prstat = procstat_open_kvm(nlistf, memf);
457 else
458 prstat = procstat_open_sysctl();
459 if (prstat == NULL)
460 xo_errx(1, "procstat_open()");
461 do {
462 xocontainer = cmd->xocontainer != NULL ? cmd->xocontainer :
463 cmd->command;
464 xo_set_version(PROCSTAT_XO_VERSION);
465 xo_open_container(progname);
466 xo_open_container(xocontainer);
467
468 if ((cmd->cmp & PS_MODE_NO_KINFO_PROC) != 0) {
469 cmd->cmd(prstat, NULL);
470 goto iter;
471 }
472
473 if (aflag) {
474 p = procstat_getprocs(prstat, KERN_PROC_PROC, 0, &cnt);
475 if (p == NULL)
476 xo_errx(1, "procstat_getprocs()");
477 kinfo_proc_sort(p, cnt);
478 for (i = 0; i < cnt; i++) {
479 procstat(cmd, prstat, &p[i]);
480
481 /* Suppress header after first process. */
482 procstat_opts |= PS_OPT_NOHEADER;
483 xo_flush();
484 }
485 procstat_freeprocs(prstat, p);
486 }
487 for (i = 0; i < argc; i++) {
488 l = strtol(argv[i], &dummy, 10);
489 if (*dummy == '\0') {
490 if (l < 0)
491 usage(cmd);
492 pid = l;
493
494 p = procstat_getprocs(prstat, KERN_PROC_PID,
495 pid, &cnt);
496 if (p == NULL)
497 xo_errx(1, "procstat_getprocs()");
498 if (cnt != 0)
499 procstat(cmd, prstat, p);
500 procstat_freeprocs(prstat, p);
501 } else {
502 if ((cmd->cmp & PS_MODE_COMPAT) == 0) {
503 cprstat = procstat_open_core(argv[i]);
504 if (cprstat == NULL) {
505 warnx("procstat_open()");
506 continue;
507 }
508 p = procstat_getprocs(cprstat,
509 KERN_PROC_PID, -1, &cnt);
510 if (p == NULL) {
511 xo_errx(1,
512 "procstat_getprocs()");
513 }
514 if (cnt != 0)
515 procstat(cmd, cprstat, p);
516 procstat_freeprocs(cprstat, p);
517 procstat_close(cprstat);
518 } else {
519 usage(cmd);
520 }
521 }
522 if ((cmd->cmp & PS_MODE_COMPAT) == 0) {
523 /* Suppress header after first process. */
524 procstat_opts |= PS_OPT_NOHEADER;
525 }
526 }
527
528 iter:
529 xo_close_container(xocontainer);
530 xo_close_container(progname);
531 xo_finish();
532 if (interval)
533 sleep(interval);
534 } while (interval);
535
536 procstat_close(prstat);
537
538 exit(0);
539 }
540
541 void
cmdopt_none(int argc,char * const argv[])542 cmdopt_none(int argc, char * const argv[])
543 {
544 int ch;
545
546 while ((ch = getopt(argc, argv, "")) != -1) {
547 switch (ch) {
548 case '?':
549 default:
550 usage(NULL);
551 }
552 }
553 }
554
555 void
cmdopt_verbose(int argc,char * const argv[])556 cmdopt_verbose(int argc, char * const argv[])
557 {
558 int ch;
559
560 while ((ch = getopt(argc, argv, "v")) != -1) {
561 switch (ch) {
562 case 'v':
563 procstat_opts |= PS_OPT_VERBOSE;
564 break;
565 case '?':
566 default:
567 usage(NULL);
568 }
569 }
570 }
571
572 void
cmdopt_signals(int argc,char * const argv[])573 cmdopt_signals(int argc, char * const argv[])
574 {
575 int ch;
576
577 while ((ch = getopt(argc, argv, "n")) != -1) {
578 switch (ch) {
579 case 'n':
580 procstat_opts |= PS_OPT_SIGNUM;
581 break;
582 case '?':
583 default:
584 usage(NULL);
585 }
586 }
587 }
588
589 void
cmdopt_rusage(int argc,char * const argv[])590 cmdopt_rusage(int argc, char * const argv[])
591 {
592 int ch;
593
594 while ((ch = getopt(argc, argv, "Ht")) != -1) {
595 switch (ch) {
596 case 'H':
597 /* FALLTHROUGH */
598 case 't':
599 procstat_opts |= PS_OPT_PERTHREAD;
600 break;
601 case '?':
602 default:
603 usage(NULL);
604 }
605 }
606 }
607
608 void
cmdopt_files(int argc,char * const argv[])609 cmdopt_files(int argc, char * const argv[])
610 {
611 int ch;
612
613 while ((ch = getopt(argc, argv, "C")) != -1) {
614 switch (ch) {
615 case 'C':
616 procstat_opts |= PS_OPT_CAPABILITIES;
617 break;
618 case '?':
619 default:
620 usage(NULL);
621 }
622 }
623 }
624
625 void
cmdopt_cpuset(int argc,char * const argv[])626 cmdopt_cpuset(int argc, char * const argv[])
627 {
628
629 procstat_opts |= PS_OPT_PERTHREAD;
630 cmdopt_none(argc, argv);
631 }
632