usr.sbin/sa/pdb.c

   1 /*
   2  * Copyright (c) 1994 Christopher G. Demetriou
   3  * 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  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Christopher G. Demetriou.
  16  * 4. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef lint
  32 static const char rcsid[] =
  33   "$FreeBSD$";
  34 #endif /* not lint */
  35
  36 #include <sys/types.h>
  37 #include <sys/acct.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <stdint.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include "extern.h"
  45 #include "pathnames.h"
  46
  47 static int check_junk __P((struct cmdinfo *));
  48 static void add_ci __P((const struct cmdinfo *, struct cmdinfo *));
  49 static void print_ci __P((const struct cmdinfo *, const struct cmdinfo *));
  50
  51 static DB       *pacct_db;
  52
  53 int
  54 pacct_init()
  55 {
  56         DB *saved_pacct_db;
  57         int error;
  58
  59         pacct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, NULL);
  60         if (pacct_db == NULL)
  61                 return (-1);
  62
  63         error = 0;
  64         if (!iflag) {
  65                 DBT key, data;
  66                 int serr, nerr;
  67
  68                 saved_pacct_db = dbopen(_PATH_SAVACCT, O_RDONLY, 0, DB_BTREE,
  69                     NULL);
  70                 if (saved_pacct_db == NULL) {
  71                         error = errno == ENOENT ? 0 : -1;
  72                         if (error)
  73                                 warn("retrieving process accounting summary");
  74                         goto out;
  75                 }
  76
  77                 serr = DB_SEQ(saved_pacct_db, &key, &data, R_FIRST);
  78                 if (serr < 0) {
  79                         warn("retrieving process accounting summary");
  80                         error = -1;
  81                         goto closeout;
  82                 }
  83                 while (serr == 0) {
  84                         nerr = DB_PUT(pacct_db, &key, &data, 0);
  85                         if (nerr < 0) {
  86                                 warn("initializing process accounting stats");
  87                                 error = -1;
  88                                 break;
  89                         }
  90
  91                         serr = DB_SEQ(saved_pacct_db, &key, &data, R_NEXT);
  92                         if (serr < 0) {
  93                                 warn("retrieving process accounting summary");
  94                                 error = -1;
  95                                 break;
  96                         }
  97                 }
  98
  99 closeout:       if (DB_CLOSE(saved_pacct_db) < 0) {
 100                         warn("closing process accounting summary");
 101                         error = -1;
 102                 }
 103         }
 104
 105 out:    if (error != 0)
 106                 pacct_destroy();
 107         return (error);
 108 }
 109
 110 void
 111 pacct_destroy()
 112 {
 113         if (DB_CLOSE(pacct_db) < 0)
 114                 warn("destroying process accounting stats");
 115 }
 116
 117 int
 118 pacct_add(ci)
 119         const struct cmdinfo *ci;
 120 {
 121         DBT key, data;
 122         struct cmdinfo newci;
 123         char keydata[sizeof ci->ci_comm];
 124         int rv;
 125
 126         bcopy(ci->ci_comm, &keydata, sizeof keydata);
 127         key.data = &keydata;
 128         key.size = strlen(keydata);
 129
 130         rv = DB_GET(pacct_db, &key, &data, 0);
 131         if (rv < 0) {
 132                 warn("get key %s from process accounting stats", ci->ci_comm);
 133                 return (-1);
 134         } else if (rv == 0) {   /* it's there; copy whole thing */
 135                 /* XXX compare size if paranoid */
 136                 /* add the old data to the new data */
 137                 bcopy(data.data, &newci, data.size);
 138         } else {                /* it's not there; zero it and copy the key */
 139                 bzero(&newci, sizeof newci);
 140                 bcopy(key.data, newci.ci_comm, key.size);
 141         }
 142
 143         add_ci(ci, &newci);
 144
 145         data.data = &newci;
 146         data.size = sizeof newci;
 147         rv = DB_PUT(pacct_db, &key, &data, 0);
 148         if (rv < 0) {
 149                 warn("add key %s to process accounting stats", ci->ci_comm);
 150                 return (-1);
 151         } else if (rv == 1) {
 152                 warnx("duplicate key %s in process accounting stats",
 153                     ci->ci_comm);
 154                 return (-1);
 155         }
 156
 157         return (0);
 158 }
 159
 160 int
 161 pacct_update()
 162 {
 163         DB *saved_pacct_db;
 164         DBT key, data;
 165         int error, serr, nerr;
 166
 167         saved_pacct_db = dbopen(_PATH_SAVACCT, O_RDWR|O_CREAT|O_TRUNC, 0644,
 168             DB_BTREE, NULL);
 169         if (saved_pacct_db == NULL) {
 170                 warn("creating process accounting summary");
 171                 return (-1);
 172         }
 173
 174         error = 0;
 175
 176         serr = DB_SEQ(pacct_db, &key, &data, R_FIRST);
 177         if (serr < 0) {
 178                 warn("retrieving process accounting stats");
 179                 error = -1;
 180         }
 181         while (serr == 0) {
 182                 nerr = DB_PUT(saved_pacct_db, &key, &data, 0);
 183                 if (nerr < 0) {
 184                         warn("saving process accounting summary");
 185                         error = -1;
 186                         break;
 187                 }
 188
 189                 serr = DB_SEQ(pacct_db, &key, &data, R_NEXT);
 190                 if (serr < 0) {
 191                         warn("retrieving process accounting stats");
 192                         error = -1;
 193                         break;
 194                 }
 195         }
 196
 197         if (DB_SYNC(saved_pacct_db, 0) < 0) {
 198                 warn("syncing process accounting summary");
 199                 error = -1;
 200         }
 201         if (DB_CLOSE(saved_pacct_db) < 0) {
 202                 warn("closing process accounting summary");
 203                 error = -1;
 204         }
 205         return error;
 206 }
 207
 208 void
 209 pacct_print()
 210 {
 211         BTREEINFO bti;
 212         DBT key, data, ndata;
 213         DB *output_pacct_db;
 214         struct cmdinfo *cip, ci, ci_total, ci_other, ci_junk;
 215         int rv;
 216
 217         bzero(&ci_total, sizeof ci_total);
 218         strcpy(ci_total.ci_comm, "");
 219         bzero(&ci_other, sizeof ci_other);
 220         strcpy(ci_other.ci_comm, "***other");
 221         bzero(&ci_junk, sizeof ci_junk);
 222         strcpy(ci_junk.ci_comm, "**junk**");
 223
 224         /*
 225          * Retrieve them into new DB, sorted by appropriate key.
 226          * At the same time, cull 'other' and 'junk'
 227          */
 228         bzero(&bti, sizeof bti);
 229         bti.compare = sa_cmp;
 230         output_pacct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, &bti);
 231         if (output_pacct_db == NULL) {
 232                 warn("couldn't sort process accounting stats");
 233                 return;
 234         }
 235
 236         ndata.data = NULL;
 237         ndata.size = 0;
 238         rv = DB_SEQ(pacct_db, &key, &data, R_FIRST);
 239         if (rv < 0)
 240                 warn("retrieving process accounting stats");
 241         while (rv == 0) {
 242                 cip = (struct cmdinfo *) data.data;
 243                 bcopy(cip, &ci, sizeof ci);
 244
 245                 /* add to total */
 246                 add_ci(&ci, &ci_total);
 247
 248                 if (vflag && ci.ci_calls <= cutoff &&
 249                     (fflag || check_junk(&ci))) {
 250                         /* put it into **junk** */
 251                         add_ci(&ci, &ci_junk);
 252                         goto next;
 253                 }
 254                 if (!aflag &&
 255                     ((ci.ci_flags & CI_UNPRINTABLE) != 0 || ci.ci_calls <= 1)) {
 256                         /* put into ***other */
 257                         add_ci(&ci, &ci_other);
 258                         goto next;
 259                 }
 260                 rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
 261                 if (rv < 0)
 262                         warn("sorting process accounting stats");
 263
 264 next:           rv = DB_SEQ(pacct_db, &key, &data, R_NEXT);
 265                 if (rv < 0)
 266                         warn("retrieving process accounting stats");
 267         }
 268
 269         /* insert **junk** and ***other */
 270         if (ci_junk.ci_calls != 0) {
 271                 data.data = &ci_junk;
 272                 data.size = sizeof ci_junk;
 273                 rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
 274                 if (rv < 0)
 275                         warn("sorting process accounting stats");
 276         }
 277         if (ci_other.ci_calls != 0) {
 278                 data.data = &ci_other;
 279                 data.size = sizeof ci_other;
 280                 rv = DB_PUT(output_pacct_db, &data, &ndata, 0);
 281                 if (rv < 0)
 282                         warn("sorting process accounting stats");
 283         }
 284
 285         /* print out the total */
 286         print_ci(&ci_total, &ci_total);
 287
 288         /* print out; if reversed, print first (smallest) first */
 289         rv = DB_SEQ(output_pacct_db, &data, &ndata, rflag ? R_FIRST : R_LAST);
 290         if (rv < 0)
 291                 warn("retrieving process accounting report");
 292         while (rv == 0) {
 293                 cip = (struct cmdinfo *) data.data;
 294                 bcopy(cip, &ci, sizeof ci);
 295
 296                 print_ci(&ci, &ci_total);
 297
 298                 rv = DB_SEQ(output_pacct_db, &data, &ndata,
 299                     rflag ? R_NEXT : R_PREV);
 300                 if (rv < 0)
 301                         warn("retrieving process accounting report");
 302         }
 303         DB_CLOSE(output_pacct_db);
 304 }
 305
 306 static int
 307 check_junk(cip)
 308         struct cmdinfo *cip;
 309 {
 310         char *cp;
 311         size_t len;
 312
 313         fprintf(stderr, "%s (%ju) -- ", cip->ci_comm, (uintmax_t)cip->ci_calls);
 314         cp = fgetln(stdin, &len);
 315
 316         return (cp && (cp[0] == 'y' || cp[0] == 'Y')) ? 1 : 0;
 317 }
 318
 319 static void
 320 add_ci(fromcip, tocip)
 321         const struct cmdinfo *fromcip;
 322         struct cmdinfo *tocip;
 323 {
 324         tocip->ci_calls += fromcip->ci_calls;
 325         tocip->ci_etime += fromcip->ci_etime;
 326         tocip->ci_utime += fromcip->ci_utime;
 327         tocip->ci_stime += fromcip->ci_stime;
 328         tocip->ci_mem += fromcip->ci_mem;
 329         tocip->ci_io += fromcip->ci_io;
 330 }
 331
 332 static void
 333 print_ci(cip, totalcip)
 334         const struct cmdinfo *cip, *totalcip;
 335 {
 336         double t, c;
 337         int uflow;
 338
 339         c = cip->ci_calls ? cip->ci_calls : 1;
 340         t = (cip->ci_utime + cip->ci_stime) / (double) AHZ;
 341         if (t < 0.01) {
 342                 t = 0.01;
 343                 uflow = 1;
 344         } else
 345                 uflow = 0;
 346
 347         printf("%8ju ", (uintmax_t)cip->ci_calls);
 348         if (cflag) {
 349                 if (cip != totalcip)
 350                         printf(" %4.2f%%  ",
 351                             cip->ci_calls / (double) totalcip->ci_calls);
 352                 else
 353                         printf(" %4s   ", "");
 354         }
 355
 356         if (jflag)
 357                 printf("%11.2fre ", cip->ci_etime / (double) (AHZ * c));
 358         else
 359                 printf("%11.2fre ", cip->ci_etime / (60.0 * AHZ));
 360         if (cflag) {
 361                 if (cip != totalcip)
 362                         printf(" %4.2f%%  ",
 363                             cip->ci_etime / (double) totalcip->ci_etime);
 364                 else
 365                         printf(" %4s   ", "");
 366         }
 367
 368         if (!lflag) {
 369                 if (jflag)
 370                         printf("%11.2fcp ", t / (double) cip->ci_calls);
 371                 else
 372                         printf("%11.2fcp ", t / 60.0);
 373                 if (cflag) {
 374                         if (cip != totalcip)
 375                                 printf(" %4.2f%%  ",
 376                                     (cip->ci_utime + cip->ci_stime) / (double)
 377                                     (totalcip->ci_utime + totalcip->ci_stime));
 378                         else
 379                                 printf(" %4s   ", "");
 380                 }
 381         } else {
 382                 if (jflag)
 383                         printf("%11.2fu ", cip->ci_utime / (double) (AHZ * c));
 384                 else
 385                         printf("%11.2fu ", cip->ci_utime / (60.0 * AHZ));
 386                 if (cflag) {
 387                         if (cip != totalcip)
 388                                 printf(" %4.2f%%  ", cip->ci_utime / (double) totalcip->ci_utime);
 389                         else
 390                                 printf(" %4s   ", "");
 391                 }
 392                 if (jflag)
 393                         printf("%11.2fs ", cip->ci_stime / (double) (AHZ * c));
 394                 else
 395                         printf("%11.2fs ", cip->ci_stime / (60.0 * AHZ));
 396                 if (cflag) {
 397                         if (cip != totalcip)
 398                                 printf(" %4.2f%%  ", cip->ci_stime / (double) totalcip->ci_stime);
 399                         else
 400                                 printf(" %4s   ", "");
 401                 }
 402         }
 403
 404         if (tflag) {
 405                 if (!uflow)
 406                         printf("%8.2fre/cp ",
 407                             cip->ci_etime /
 408                             (double) (cip->ci_utime + cip->ci_stime));
 409                 else
 410                         printf("*ignore*      ");
 411         }
 412
 413         if (Dflag)
 414                 printf("%10jutio ", (uintmax_t)cip->ci_io);
 415         else
 416                 printf("%8.0favio ", cip->ci_io / c);
 417
 418         if (Kflag)
 419                 printf("%10juk*sec ", (uintmax_t)cip->ci_mem);
 420         else
 421                 printf("%8.0fk ", cip->ci_mem / t);
 422
 423         printf("  %s\n", cip->ci_comm);
 424 }