File: | src/bin/ps/ps.c |
Warning: | line 255, column 2 Value stored to 'argc' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: ps.c,v 1.78 2021/12/01 18:21:23 deraadt Exp $ */ |
2 | /* $NetBSD: ps.c,v 1.15 1995/05/18 20:33:25 mycroft Exp $ */ |
3 | |
4 | /*- |
5 | * Copyright (c) 1990, 1993, 1994 |
6 | * The Regents of the University of California. All rights reserved. |
7 | * |
8 | * Redistribution and use in source and binary forms, with or without |
9 | * modification, are permitted provided that the following conditions |
10 | * are met: |
11 | * 1. Redistributions of source code must retain the above copyright |
12 | * notice, this list of conditions and the following disclaimer. |
13 | * 2. Redistributions in binary form must reproduce the above copyright |
14 | * notice, this list of conditions and the following disclaimer in the |
15 | * documentation and/or other materials provided with the distribution. |
16 | * 3. Neither the name of the University nor the names of its contributors |
17 | * may be used to endorse or promote products derived from this software |
18 | * without specific prior written permission. |
19 | * |
20 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
21 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
22 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
23 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
24 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
25 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
26 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
27 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
28 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
29 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
30 | * SUCH DAMAGE. |
31 | */ |
32 | |
33 | #include <sys/param.h> /* NODEV */ |
34 | #include <sys/types.h> |
35 | #include <sys/signal.h> |
36 | #include <sys/sysctl.h> |
37 | #include <sys/time.h> |
38 | #include <sys/resource.h> |
39 | #include <sys/proc.h> |
40 | #include <sys/stat.h> |
41 | #include <sys/ioctl.h> |
42 | |
43 | #include <ctype.h> |
44 | #include <err.h> |
45 | #include <errno(*__errno()).h> |
46 | #include <fcntl.h> |
47 | #include <kvm.h> |
48 | #include <locale.h> |
49 | #include <nlist.h> |
50 | #include <paths.h> |
51 | #include <pwd.h> |
52 | #include <stdio.h> |
53 | #include <stdlib.h> |
54 | #include <string.h> |
55 | #include <unistd.h> |
56 | #include <limits.h> |
57 | |
58 | #include "ps.h" |
59 | |
60 | extern char *__progname; |
61 | |
62 | struct varent *vhead; |
63 | |
64 | int eval; /* exit value */ |
65 | int sumrusage; /* -S */ |
66 | int termwidth; /* width of screen (0 == infinity) */ |
67 | int totwidth; /* calculated width of requested variables */ |
68 | |
69 | int needcomm, needenv, neednlist, commandonly; |
70 | |
71 | enum sort { DEFAULT, SORTMEM, SORTCPU } sortby = DEFAULT; |
72 | |
73 | static char *kludge_oldps_options(char *); |
74 | static int pscomp(const void *, const void *); |
75 | static void scanvars(void); |
76 | static void usage(void); |
77 | |
78 | char dfmt[] = "pid tt state time command"; |
79 | char tfmt[] = "pid tid tt state time command"; |
80 | char jfmt[] = "user pid ppid pgid sess jobc state tt time command"; |
81 | char lfmt[] = "uid pid ppid cpu pri nice vsz rss wchan state tt time command"; |
82 | char o1[] = "pid"; |
83 | char o2[] = "tt state time command"; |
84 | char ufmt[] = "user pid %cpu %mem vsz rss tt state start time command"; |
85 | char vfmt[] = "pid state time sl re pagein vsz rss lim tsiz %cpu %mem command"; |
86 | |
87 | kvm_t *kd; |
88 | int kvm_sysctl_only; |
89 | |
90 | int |
91 | main(int argc, char *argv[]) |
92 | { |
93 | struct kinfo_proc *kp, **kinfo; |
94 | struct varent *vent; |
95 | struct winsize ws; |
96 | dev_t ttydev; |
97 | pid_t pid; |
98 | uid_t uid; |
99 | int all, ch, flag, i, fmt, lineno, nentries; |
100 | int prtheader, showthreads, wflag, kflag, what, Uflag, xflg; |
101 | char *nlistf, *memf, *swapf, *cols, errbuf[_POSIX2_LINE_MAX2048]; |
102 | |
103 | setlocale(LC_CTYPE2, ""); |
104 | |
105 | termwidth = 0; |
106 | if ((cols = getenv("COLUMNS")) != NULL((void *)0)) |
107 | termwidth = strtonum(cols, 1, INT_MAX2147483647, NULL((void *)0)); |
108 | if (termwidth == 0 && |
109 | (ioctl(STDOUT_FILENO1, TIOCGWINSZ((unsigned long)0x40000000 | ((sizeof(struct winsize) & 0x1fff ) << 16) | ((('t')) << 8) | ((104))), &ws) == 0 || |
110 | ioctl(STDERR_FILENO2, TIOCGWINSZ((unsigned long)0x40000000 | ((sizeof(struct winsize) & 0x1fff ) << 16) | ((('t')) << 8) | ((104))), &ws) == 0 || |
111 | ioctl(STDIN_FILENO0, TIOCGWINSZ((unsigned long)0x40000000 | ((sizeof(struct winsize) & 0x1fff ) << 16) | ((('t')) << 8) | ((104))), &ws) == 0) && |
112 | ws.ws_col > 0) |
113 | termwidth = ws.ws_col - 1; |
114 | if (termwidth == 0) |
115 | termwidth = 79; |
116 | |
117 | if (argc > 1) |
118 | argv[1] = kludge_oldps_options(argv[1]); |
119 | |
120 | all = fmt = prtheader = showthreads = wflag = kflag = Uflag = xflg = 0; |
121 | pid = -1; |
122 | uid = 0; |
123 | ttydev = NODEV(dev_t)(-1); |
124 | memf = nlistf = swapf = NULL((void *)0); |
125 | while ((ch = getopt(argc, argv, |
126 | "AaCcegHhjkLlM:mN:O:o:p:rSTt:U:uvW:wx")) != -1) |
127 | switch (ch) { |
128 | case 'A': |
129 | all = 1; |
130 | xflg = 1; |
131 | break; |
132 | case 'a': |
133 | all = 1; |
134 | break; |
135 | case 'C': |
136 | break; /* no-op */ |
137 | case 'c': |
138 | commandonly = 1; |
139 | break; |
140 | case 'e': /* XXX set ufmt */ |
141 | needenv = 1; |
142 | break; |
143 | case 'g': |
144 | break; /* no-op */ |
145 | case 'H': |
146 | showthreads = 1; |
147 | break; |
148 | case 'h': |
149 | prtheader = ws.ws_row > 5 ? ws.ws_row : 22; |
150 | break; |
151 | case 'j': |
152 | parsefmt(jfmt); |
153 | fmt = 1; |
154 | jfmt[0] = '\0'; |
155 | break; |
156 | case 'k': |
157 | kflag = 1; |
158 | break; |
159 | case 'L': |
160 | showkey(); |
161 | exit(0); |
162 | case 'l': |
163 | parsefmt(lfmt); |
164 | fmt = 1; |
165 | lfmt[0] = '\0'; |
166 | break; |
167 | case 'M': |
168 | memf = optarg; |
169 | break; |
170 | case 'm': |
171 | sortby = SORTMEM; |
172 | break; |
173 | case 'N': |
174 | nlistf = optarg; |
175 | break; |
176 | case 'O': |
177 | parsefmt(o1); |
178 | parsefmt(optarg); |
179 | parsefmt(o2); |
180 | o1[0] = o2[0] = '\0'; |
181 | fmt = 1; |
182 | break; |
183 | case 'o': |
184 | parsefmt(optarg); |
185 | fmt = 1; |
186 | break; |
187 | case 'p': |
188 | pid = atol(optarg); |
189 | xflg = 1; |
190 | break; |
191 | case 'r': |
192 | sortby = SORTCPU; |
193 | break; |
194 | case 'S': |
195 | sumrusage = 1; |
196 | break; |
197 | case 'T': |
198 | if ((optarg = ttyname(STDIN_FILENO0)) == NULL((void *)0)) |
199 | errx(1, "stdin: not a terminal"); |
200 | /* FALLTHROUGH */ |
201 | case 't': { |
202 | struct stat sb; |
203 | char *ttypath, pathbuf[PATH_MAX1024]; |
204 | |
205 | if (strcmp(optarg, "co") == 0) |
206 | ttypath = _PATH_CONSOLE"/dev/console"; |
207 | else if (*optarg != '/') { |
208 | int r = snprintf(pathbuf, sizeof(pathbuf), "%s%s", |
209 | _PATH_TTY"/dev/tty", optarg); |
210 | if (r < 0 || r > sizeof(pathbuf)) |
211 | errx(1, "%s: too long\n", optarg); |
212 | ttypath = pathbuf; |
213 | } else |
214 | ttypath = optarg; |
215 | if (stat(ttypath, &sb) == -1) |
216 | err(1, "%s", ttypath); |
217 | if (!S_ISCHR(sb.st_mode)((sb.st_mode & 0170000) == 0020000)) |
218 | errx(1, "%s: not a terminal", ttypath); |
219 | ttydev = sb.st_rdev; |
220 | break; |
221 | } |
222 | case 'U': |
223 | if (uid_from_user(optarg, &uid) == -1) |
224 | errx(1, "%s: no such user", optarg); |
225 | Uflag = xflg = 1; |
226 | break; |
227 | case 'u': |
228 | parsefmt(ufmt); |
229 | sortby = SORTCPU; |
230 | fmt = 1; |
231 | ufmt[0] = '\0'; |
232 | break; |
233 | case 'v': |
234 | parsefmt(vfmt); |
235 | sortby = SORTMEM; |
236 | fmt = 1; |
237 | vfmt[0] = '\0'; |
238 | break; |
239 | case 'W': |
240 | swapf = optarg; |
241 | break; |
242 | case 'w': |
243 | if (wflag) |
244 | termwidth = UNLIMITED0; |
245 | else if (termwidth < 131) |
246 | termwidth = 131; |
247 | wflag = 1; |
248 | break; |
249 | case 'x': |
250 | xflg = 1; |
251 | break; |
252 | default: |
253 | usage(); |
254 | } |
255 | argc -= optind; |
Value stored to 'argc' is never read | |
256 | argv += optind; |
257 | |
258 | #define BACKWARD_COMPATIBILITY |
259 | #ifdef BACKWARD_COMPATIBILITY |
260 | if (*argv) { |
261 | nlistf = *argv; |
262 | if (*++argv) { |
263 | memf = *argv; |
264 | if (*++argv) |
265 | swapf = *argv; |
266 | } |
267 | } |
268 | #endif |
269 | |
270 | if (nlistf == NULL((void *)0) && memf == NULL((void *)0) && swapf == NULL((void *)0)) { |
271 | kd = kvm_openfiles(NULL((void *)0), NULL((void *)0), NULL((void *)0), KVM_NO_FILES0x80000000, errbuf); |
272 | kvm_sysctl_only = 1; |
273 | } else { |
274 | kd = kvm_openfiles(nlistf, memf, swapf, O_RDONLY0x0000, errbuf); |
275 | } |
276 | if (kd == NULL((void *)0)) |
277 | errx(1, "%s", errbuf); |
278 | |
279 | if (unveil(_PATH_DEVDB"/var/run/dev.db", "r") == -1 && errno(*__errno()) != ENOENT2) |
280 | err(1, "unveil %s", _PATH_DEVDB"/var/run/dev.db"); |
281 | if (unveil(_PATH_DEV"/dev/", "r") == -1 && errno(*__errno()) != ENOENT2) |
282 | err(1, "unveil %s", _PATH_DEV"/dev/"); |
283 | if (swapf) |
284 | if (unveil(swapf, "r") == -1) |
285 | err(1, "unveil %s", swapf); |
286 | if (nlistf) |
287 | if (unveil(nlistf, "r") == -1) |
288 | err(1, "unveil %s", nlistf); |
289 | if (memf) |
290 | if (unveil(memf, "r") == -1) |
291 | err(1, "unveil %s", memf); |
292 | if (pledge("stdio rpath getpw ps", NULL((void *)0)) == -1) |
293 | err(1, "pledge"); |
294 | |
295 | if (!fmt) { |
296 | if (showthreads) |
297 | parsefmt(tfmt); |
298 | else |
299 | parsefmt(dfmt); |
300 | } |
301 | |
302 | /* XXX - should be cleaner */ |
303 | if (!all && ttydev == NODEV(dev_t)(-1) && pid == -1 && !Uflag) { |
304 | uid = getuid(); |
305 | Uflag = 1; |
306 | } |
307 | |
308 | /* |
309 | * scan requested variables, noting what structures are needed, |
310 | * and adjusting header widths as appropriate. |
311 | */ |
312 | scanvars(); |
313 | |
314 | if (neednlist && !nlistread) |
315 | (void) donlist(); |
316 | |
317 | /* |
318 | * get proc list |
319 | */ |
320 | if (Uflag) { |
321 | what = KERN_PROC_UID5; |
322 | flag = uid; |
323 | } else if (ttydev != NODEV(dev_t)(-1)) { |
324 | what = KERN_PROC_TTY4; |
325 | flag = ttydev; |
326 | } else if (pid != -1) { |
327 | what = KERN_PROC_PID1; |
328 | flag = pid; |
329 | } else if (kflag) { |
330 | what = KERN_PROC_KTHREAD7; |
331 | flag = 0; |
332 | } else { |
333 | what = KERN_PROC_ALL0; |
334 | flag = 0; |
335 | } |
336 | if (showthreads) |
337 | what |= KERN_PROC_SHOW_THREADS0x40000000; |
338 | |
339 | /* |
340 | * select procs |
341 | */ |
342 | kp = kvm_getprocs(kd, what, flag, sizeof(*kp), &nentries); |
343 | if (kp == NULL((void *)0)) |
344 | errx(1, "%s", kvm_geterr(kd)); |
345 | |
346 | /* |
347 | * print header |
348 | */ |
349 | printheader(); |
350 | if (nentries == 0) |
351 | exit(1); |
352 | /* |
353 | * sort proc list, we convert from an array of structs to an array |
354 | * of pointers to make the sort cheaper. |
355 | */ |
356 | if ((kinfo = reallocarray(NULL((void *)0), nentries, sizeof(*kinfo))) == NULL((void *)0)) |
357 | err(1, "failed to allocate memory for proc pointers"); |
358 | for (i = 0; i < nentries; i++) |
359 | kinfo[i] = &kp[i]; |
360 | qsort(kinfo, nentries, sizeof(*kinfo), pscomp); |
361 | /* |
362 | * for each proc, call each variable output function. |
363 | */ |
364 | for (i = lineno = 0; i < nentries; i++) { |
365 | if (xflg == 0 && ((int)kinfo[i]->p_tdev == NODEV(dev_t)(-1) || |
366 | (kinfo[i]->p_psflags & PS_CONTROLT0x00000001 ) == 0)) |
367 | continue; |
368 | if (showthreads && kinfo[i]->p_tid == -1) |
369 | continue; |
370 | for (vent = vhead; vent; vent = vent->next) { |
371 | (vent->var->oproc)(kinfo[i], vent); |
372 | if (vent->next != NULL((void *)0)) |
373 | (void)putchar(' ')(!__isthreaded ? __sputc(' ', (&__sF[1])) : (putc)(' ', ( &__sF[1]))); |
374 | } |
375 | (void)putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n', (&__sF[1]))); |
376 | if (prtheader && lineno++ == prtheader - 4) { |
377 | (void)putchar('\n')(!__isthreaded ? __sputc('\n', (&__sF[1])) : (putc)('\n', (&__sF[1]))); |
378 | printheader(); |
379 | lineno = 0; |
380 | } |
381 | } |
382 | exit(eval); |
383 | } |
384 | |
385 | static void |
386 | scanvars(void) |
387 | { |
388 | struct varent *vent; |
389 | VAR *v; |
390 | int i; |
391 | |
392 | for (vent = vhead; vent; vent = vent->next) { |
393 | v = vent->var; |
394 | i = strlen(v->header); |
395 | if (v->width < i) |
396 | v->width = i; |
397 | totwidth += v->width + 1; /* +1 for space */ |
398 | if (v->flag & COMM0x01) |
399 | needcomm = 1; |
400 | if (v->flag & NLIST0x10) |
401 | neednlist = 1; |
402 | } |
403 | totwidth--; |
404 | } |
405 | |
406 | static int |
407 | pscomp(const void *v1, const void *v2) |
408 | { |
409 | const struct kinfo_proc *kp1 = *(const struct kinfo_proc **)v1; |
410 | const struct kinfo_proc *kp2 = *(const struct kinfo_proc **)v2; |
411 | int i; |
412 | #define VSIZE(k)((k)->p_vm_dsize + (k)->p_vm_ssize + (k)->p_vm_tsize ) ((k)->p_vm_dsize + (k)->p_vm_ssize + (k)->p_vm_tsize) |
413 | |
414 | if (sortby == SORTCPU && (i = getpcpu(kp2) - getpcpu(kp1)) != 0) |
415 | return (i); |
416 | if (sortby == SORTMEM && (i = VSIZE(kp2)((kp2)->p_vm_dsize + (kp2)->p_vm_ssize + (kp2)->p_vm_tsize ) - VSIZE(kp1)((kp1)->p_vm_dsize + (kp1)->p_vm_ssize + (kp1)->p_vm_tsize )) != 0) |
417 | return (i); |
418 | if ((i = kp1->p_tdev - kp2->p_tdev) == 0 && |
419 | (i = kp1->p_ustart_sec - kp2->p_ustart_sec) == 0) |
420 | i = kp1->p_ustart_usec - kp2->p_ustart_usec; |
421 | return (i); |
422 | } |
423 | |
424 | /* |
425 | * ICK (all for getopt), would rather hide the ugliness |
426 | * here than taint the main code. |
427 | * |
428 | * ps foo -> ps -foo |
429 | * ps 34 -> ps -p34 |
430 | * |
431 | * The old convention that 't' with no trailing tty arg means the users |
432 | * tty, is only supported if argv[1] doesn't begin with a '-'. This same |
433 | * feature is available with the option 'T', which takes no argument. |
434 | */ |
435 | static char * |
436 | kludge_oldps_options(char *s) |
437 | { |
438 | size_t len; |
439 | char *newopts, *ns, *cp; |
440 | |
441 | len = strlen(s); |
442 | if ((newopts = ns = malloc(2 + len + 1)) == NULL((void *)0)) |
443 | err(1, NULL((void *)0)); |
444 | /* |
445 | * options begin with '-' |
446 | */ |
447 | if (*s != '-') |
448 | *ns++ = '-'; /* add option flag */ |
449 | |
450 | /* |
451 | * gaze to end of argv[1] |
452 | */ |
453 | cp = s + len - 1; |
454 | /* |
455 | * if last letter is a 't' flag with no argument (in the context |
456 | * of the oldps options -- option string NOT starting with a '-' -- |
457 | * then convert to 'T' (meaning *this* terminal, i.e. ttyname(0)). |
458 | */ |
459 | if (*cp == 't' && *s != '-') |
460 | *cp = 'T'; |
461 | else { |
462 | /* |
463 | * otherwise check for trailing number, which *may* be a |
464 | * pid. |
465 | */ |
466 | while (cp >= s && isdigit((unsigned char)*cp)) |
467 | --cp; |
468 | } |
469 | cp++; |
470 | memmove(ns, s, (size_t)(cp - s)); /* copy up to trailing number */ |
471 | ns += cp - s; |
472 | /* |
473 | * if there's a trailing number, and not a preceding 'p' (pid) or |
474 | * 't' (tty) flag, then assume it's a pid and insert a 'p' flag. |
475 | */ |
476 | if (isdigit((unsigned char)*cp) && |
477 | (cp == s || (cp[-1] != 't' && cp[-1] != 'p' && |
478 | (cp - 1 == s || cp[-2] != 't')))) |
479 | *ns++ = 'p'; |
480 | /* and append the number */ |
481 | (void)strlcpy(ns, cp, newopts + len + 3 - ns); |
482 | |
483 | return (newopts); |
484 | } |
485 | |
486 | static void |
487 | usage(void) |
488 | { |
489 | (void)fprintf(stderr(&__sF[2]), |
490 | "usage: %s [-AaceHhjkLlmrSTuvwx] [-M core] [-N system] [-O fmt] [-o fmt] [-p pid]\n", |
491 | __progname); |
492 | (void)fprintf(stderr(&__sF[2]), |
493 | "%-*s[-t tty] [-U username] [-W swap]\n", (int)strlen(__progname) + 8, ""); |
494 | exit(1); |
495 | } |