1 /* $OpenBSD: main.c,v 1.19 2022/12/04 23:50:51 cheloha Exp $ */
2 /*
3 * Copyright (c) 1994 Christopher G. Demetriou
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by Christopher G. Demetriou.
17 * 4. The name of the author may not be used to endorse or promote products
18 * derived from this software without specific prior written permission
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * sa: system accounting
34 */
35
36 #include <sys/types.h>
37 #include <sys/acct.h>
38 #include <ctype.h>
39 #include <err.h>
40 #include <fcntl.h>
41 #include <signal.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <unistd.h>
46 #include "extern.h"
47 #include "pathnames.h"
48
49 static int acct_load(char *, int);
50 static uint64_t decode_comp_t(comp_t);
51 static int cmp_comm(const char *, const char *);
52 static int cmp_usrsys(const DBT *, const DBT *);
53 static int cmp_avgusrsys(const DBT *, const DBT *);
54 static int cmp_dkio(const DBT *, const DBT *);
55 static int cmp_avgdkio(const DBT *, const DBT *);
56 static int cmp_cpumem(const DBT *, const DBT *);
57 static int cmp_avgcpumem(const DBT *, const DBT *);
58 static int cmp_calls(const DBT *, const DBT *);
59
60 int aflag, bflag, cflag, dflag, Dflag, fflag, iflag, jflag, kflag;
61 int Kflag, lflag, mflag, qflag, rflag, sflag, tflag, uflag, vflag;
62 int cutoff = 1;
63
64 static char *dfltargv[] = { _PATH_ACCT };
65 static int dfltargc = (sizeof(dfltargv)/sizeof(char *));
66
67 /* default to comparing by sum of user + system time */
68 cmpf_t sa_cmp = cmp_usrsys;
69
70 int
main(int argc,char ** argv)71 main(int argc, char **argv)
72 {
73 int ch;
74 int error = 0;
75 const char *errstr;
76 extern char *__progname;
77
78 if (pledge("stdio rpath wpath cpath getpw flock", NULL) == -1)
79 err(1, "pledge");
80
81 while ((ch = getopt(argc, argv, "abcdDfijkKlmnqrstuv:")) != -1)
82 switch (ch) {
83 case 'a':
84 /* print all commands */
85 aflag = 1;
86 break;
87 case 'b':
88 /* sort by per-call user/system time average */
89 bflag = 1;
90 sa_cmp = cmp_avgusrsys;
91 break;
92 case 'c':
93 /* print percentage total time */
94 cflag = 1;
95 break;
96 case 'd':
97 /* sort by averge number of disk I/O ops */
98 dflag = 1;
99 sa_cmp = cmp_avgdkio;
100 break;
101 case 'D':
102 /* print and sort by total disk I/O ops */
103 Dflag = 1;
104 sa_cmp = cmp_dkio;
105 break;
106 case 'f':
107 /* force no interactive threshold comprison */
108 fflag = 1;
109 break;
110 case 'i':
111 /* do not read in summary file */
112 iflag = 1;
113 break;
114 case 'j':
115 /* instead of total minutes, give sec/call */
116 jflag = 1;
117 break;
118 case 'k':
119 /* sort by cpu-time average memory usage */
120 kflag = 1;
121 sa_cmp = cmp_avgcpumem;
122 break;
123 case 'K':
124 /* print and sort by cpu-storage integral */
125 sa_cmp = cmp_cpumem;
126 Kflag = 1;
127 break;
128 case 'l':
129 /* separate system and user time */
130 lflag = 1;
131 break;
132 case 'm':
133 /* print procs and time per-user */
134 mflag = 1;
135 break;
136 case 'n':
137 /* sort by number of calls */
138 sa_cmp = cmp_calls;
139 break;
140 case 'q':
141 /* quiet; error messages only */
142 qflag = 1;
143 break;
144 case 'r':
145 /* reverse order of sort */
146 rflag = 1;
147 break;
148 case 's':
149 /* merge accounting file into summaries */
150 sflag = 1;
151 break;
152 case 't':
153 /* report ratio of user and system times */
154 tflag = 1;
155 break;
156 case 'u':
157 /* first, print uid and command name */
158 uflag = 1;
159 break;
160 case 'v':
161 /* cull junk */
162 vflag = 1;
163 cutoff = strtonum(optarg, 1, INT_MAX, &errstr);
164 if (errstr)
165 errx(1, "-v %s: %s", optarg, errstr);
166 break;
167 default:
168 (void)fprintf(stderr,
169 "usage: %s [-abcDdfijKklmnqrstu] [-v cutoff]"
170 " [file ...]\n", __progname);
171 exit(1);
172 }
173
174 argc -= optind;
175 argv += optind;
176
177 /* various argument checking */
178 if (fflag && !vflag)
179 errx(1, "only one of -f requires -v");
180 if (fflag && aflag)
181 errx(1, "only one of -a and -v may be specified");
182 /* XXX need more argument checking */
183
184 if (!uflag) {
185 /* initialize tables */
186 if ((sflag || (!mflag && !qflag)) && pacct_init() != 0)
187 errx(1, "process accounting initialization failed");
188 if ((sflag || (mflag && !qflag)) && usracct_init() != 0)
189 errx(1, "user accounting initialization failed");
190 }
191
192 if (argc == 0) {
193 argc = dfltargc;
194 argv = dfltargv;
195 }
196
197 /* for each file specified */
198 for (; argc > 0; argc--, argv++) {
199 int fd;
200
201 /*
202 * load the accounting data from the file.
203 * if it fails, go on to the next file.
204 */
205 fd = acct_load(argv[0], sflag);
206 if (fd < 0)
207 continue;
208
209 if (!uflag && sflag) {
210 #ifndef DEBUG
211 sigset_t nmask, omask;
212 int unmask = 1;
213
214 /*
215 * block most signals so we aren't interrupted during
216 * the update.
217 */
218 if (sigfillset(&nmask) == -1) {
219 warn("sigfillset");
220 unmask = 0;
221 error = 1;
222 }
223 if (unmask &&
224 (sigprocmask(SIG_BLOCK, &nmask, &omask) == -1)) {
225 warn("couldn't set signal mask ");
226 unmask = 0;
227 error = 1;
228 }
229 #endif /* DEBUG */
230
231 /*
232 * truncate the accounting data file ASAP, to avoid
233 * losing data. don't worry about errors in updating
234 * the saved stats; better to underbill than overbill,
235 * but we want every accounting record intact.
236 */
237 if (ftruncate(fd, 0) == -1) {
238 warn("couldn't truncate %s", *argv);
239 error = 1;
240 }
241
242 /*
243 * update saved user and process accounting data.
244 * note errors for later.
245 */
246 if (pacct_update() != 0 || usracct_update() != 0)
247 error = 1;
248
249 #ifndef DEBUG
250 /*
251 * restore signals
252 */
253 if (unmask &&
254 (sigprocmask(SIG_SETMASK, &omask, NULL) == -1)) {
255 warn("couldn't restore signal mask");
256 error = 1;
257 }
258 #endif /* DEBUG */
259 }
260
261 /*
262 * close the opened accounting file
263 */
264 if (close(fd) == -1) {
265 warn("close %s", *argv);
266 error = 1;
267 }
268 }
269
270 if (!uflag && !qflag) {
271 /* print any results we may have obtained. */
272 if (!mflag)
273 pacct_print();
274 else
275 usracct_print();
276 }
277
278 if (!uflag) {
279 /* finally, deallocate databases */
280 if (sflag || (!mflag && !qflag))
281 pacct_destroy();
282 if (sflag || (mflag && !qflag))
283 usracct_destroy();
284 }
285
286 exit(error);
287 }
288
289 static int
acct_load(char * pn,int wr)290 acct_load(char *pn, int wr)
291 {
292 struct acct ac;
293 struct cmdinfo ci;
294 ssize_t rv;
295 int fd, i;
296
297 /*
298 * open the file
299 */
300 fd = open(pn, wr ? O_RDWR : O_RDONLY);
301 if (fd == -1) {
302 warn("open %s %s", pn, wr ? "for read/write" : "read-only");
303 return (-1);
304 }
305
306 /*
307 * read all we can; don't stat and open because more processes
308 * could exit, and we'd miss them
309 */
310 while (1) {
311 /* get one accounting entry and punt if there's an error */
312 rv = read(fd, &ac, sizeof(struct acct));
313 if (rv == -1)
314 warn("error reading %s", pn);
315 else if (rv > 0 && rv < sizeof(struct acct))
316 warnx("short read of accounting data in %s", pn);
317 if (rv != sizeof(struct acct))
318 break;
319
320 /* decode it */
321 ci.ci_calls = 1;
322 for (i = 0; i < sizeof(ac.ac_comm) && ac.ac_comm[i] != '\0';
323 i++) {
324 unsigned char c = ac.ac_comm[i];
325
326 if (!isascii(c) || iscntrl(c)) {
327 ci.ci_comm[i] = '?';
328 ci.ci_flags |= CI_UNPRINTABLE;
329 } else
330 ci.ci_comm[i] = c;
331 }
332 if (ac.ac_flag & AFORK)
333 ci.ci_comm[i++] = '*';
334 ci.ci_comm[i++] = '\0';
335 ci.ci_etime = decode_comp_t(ac.ac_etime);
336 ci.ci_utime = decode_comp_t(ac.ac_utime);
337 ci.ci_stime = decode_comp_t(ac.ac_stime);
338 ci.ci_uid = ac.ac_uid;
339 ci.ci_mem = ac.ac_mem;
340 ci.ci_io = decode_comp_t(ac.ac_io) / AHZ;
341 ci.ci_pid = ac.ac_pid;
342
343 if (!uflag) {
344 /* and enter it into the usracct and pacct databases */
345 if (sflag || (!mflag && !qflag))
346 pacct_add(&ci);
347 if (sflag || (mflag && !qflag))
348 usracct_add(&ci);
349 } else if (!qflag)
350 printf("%6u %12.2f cpu %12lluk mem %12llu io pid %u %s\n",
351 ci.ci_uid,
352 (ci.ci_utime + ci.ci_stime) / (double) AHZ,
353 ci.ci_mem, ci.ci_io, ci.ci_pid, ci.ci_comm);
354 }
355
356 /* finally, return the file descriptor for possible truncation */
357 return (fd);
358 }
359
360 static uint64_t
decode_comp_t(comp_t comp)361 decode_comp_t(comp_t comp)
362 {
363 uint64_t rv;
364
365 /*
366 * for more info on the comp_t format, see:
367 * /usr/src/sys/kern/kern_acct.c
368 * /usr/src/sys/sys/acct.h
369 * /usr/src/usr.bin/lastcomm/lastcomm.c
370 */
371 rv = comp & 0x1fff; /* 13 bit fraction */
372 comp >>= 13; /* 3 bit base-8 exponent */
373 while (comp--)
374 rv <<= 3;
375
376 return (rv);
377 }
378
379 /* sort commands, doing the right thing in terms of reversals */
380 static int
cmp_comm(const char * s1,const char * s2)381 cmp_comm(const char *s1, const char *s2)
382 {
383 int rv;
384
385 rv = strcmp(s1, s2);
386 if (rv == 0)
387 rv = -1;
388 return (rflag ? rv : -rv);
389 }
390
391 /* sort by total user and system time */
392 static int
cmp_usrsys(const DBT * d1,const DBT * d2)393 cmp_usrsys(const DBT *d1, const DBT *d2)
394 {
395 struct cmdinfo c1, c2;
396 uint64_t t1, t2;
397
398 memcpy(&c1, d1->data, sizeof(c1));
399 memcpy(&c2, d2->data, sizeof(c2));
400
401 t1 = c1.ci_utime + c1.ci_stime;
402 t2 = c2.ci_utime + c2.ci_stime;
403
404 if (t1 < t2)
405 return -1;
406 else if (t1 == t2)
407 return (cmp_comm(c1.ci_comm, c2.ci_comm));
408 else
409 return 1;
410 }
411
412 /* sort by average user and system time */
413 static int
cmp_avgusrsys(const DBT * d1,const DBT * d2)414 cmp_avgusrsys(const DBT *d1, const DBT *d2)
415 {
416 struct cmdinfo c1, c2;
417 double t1, t2;
418
419 memcpy(&c1, d1->data, sizeof(c1));
420 memcpy(&c2, d2->data, sizeof(c2));
421
422 t1 = c1.ci_utime + c1.ci_stime;
423 t1 /= (double) (c1.ci_calls ? c1.ci_calls : 1);
424
425 t2 = c2.ci_utime + c2.ci_stime;
426 t2 /= (double) (c2.ci_calls ? c2.ci_calls : 1);
427
428 if (t1 < t2)
429 return -1;
430 else if (t1 == t2)
431 return (cmp_comm(c1.ci_comm, c2.ci_comm));
432 else
433 return 1;
434 }
435
436 /* sort by total number of disk I/O operations */
437 static int
cmp_dkio(const DBT * d1,const DBT * d2)438 cmp_dkio(const DBT *d1, const DBT *d2)
439 {
440 struct cmdinfo c1, c2;
441
442 memcpy(&c1, d1->data, sizeof(c1));
443 memcpy(&c2, d2->data, sizeof(c2));
444
445 if (c1.ci_io < c2.ci_io)
446 return -1;
447 else if (c1.ci_io == c2.ci_io)
448 return (cmp_comm(c1.ci_comm, c2.ci_comm));
449 else
450 return 1;
451 }
452
453 /* sort by average number of disk I/O operations */
454 static int
cmp_avgdkio(const DBT * d1,const DBT * d2)455 cmp_avgdkio(const DBT *d1, const DBT *d2)
456 {
457 struct cmdinfo c1, c2;
458 double n1, n2;
459
460 memcpy(&c1, d1->data, sizeof(c1));
461 memcpy(&c2, d2->data, sizeof(c2));
462
463 n1 = (double) c1.ci_io / (double) (c1.ci_calls ? c1.ci_calls : 1);
464 n2 = (double) c2.ci_io / (double) (c2.ci_calls ? c2.ci_calls : 1);
465
466 if (n1 < n2)
467 return -1;
468 else if (n1 == n2)
469 return (cmp_comm(c1.ci_comm, c2.ci_comm));
470 else
471 return 1;
472 }
473
474 /* sort by the cpu-storage integral */
475 static int
cmp_cpumem(const DBT * d1,const DBT * d2)476 cmp_cpumem(const DBT *d1, const DBT *d2)
477 {
478 struct cmdinfo c1, c2;
479
480 memcpy(&c1, d1->data, sizeof(c1));
481 memcpy(&c2, d2->data, sizeof(c2));
482
483 if (c1.ci_mem < c2.ci_mem)
484 return -1;
485 else if (c1.ci_mem == c2.ci_mem)
486 return (cmp_comm(c1.ci_comm, c2.ci_comm));
487 else
488 return 1;
489 }
490
491 /* sort by the cpu-time average memory usage */
492 static int
cmp_avgcpumem(const DBT * d1,const DBT * d2)493 cmp_avgcpumem(const DBT *d1, const DBT *d2)
494 {
495 struct cmdinfo c1, c2;
496 uint64_t t1, t2;
497 double n1, n2;
498
499 memcpy(&c1, d1->data, sizeof(c1));
500 memcpy(&c2, d2->data, sizeof(c2));
501
502 t1 = c1.ci_utime + c1.ci_stime;
503 t2 = c2.ci_utime + c2.ci_stime;
504
505 n1 = (double) c1.ci_mem / (double) (t1 ? t1 : 1);
506 n2 = (double) c2.ci_mem / (double) (t2 ? t2 : 1);
507
508 if (n1 < n2)
509 return -1;
510 else if (n1 == n2)
511 return (cmp_comm(c1.ci_comm, c2.ci_comm));
512 else
513 return 1;
514 }
515
516 /* sort by the number of invocations */
517 static int
cmp_calls(const DBT * d1,const DBT * d2)518 cmp_calls(const DBT *d1, const DBT *d2)
519 {
520 struct cmdinfo c1, c2;
521
522 memcpy(&c1, d1->data, sizeof(c1));
523 memcpy(&c2, d2->data, sizeof(c2));
524
525 if (c1.ci_calls < c2.ci_calls)
526 return -1;
527 else if (c1.ci_calls == c2.ci_calls)
528 return (cmp_comm(c1.ci_comm, c2.ci_comm));
529 else
530 return 1;
531 }
532