usr.sbin/sa/usrdb.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  * $FreeBSD: src/usr.sbin/sa/usrdb.c,v 1.8.2.2 2000/10/28 02:28:20 gallatin Exp $
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/types.h>
  35 #include <sys/acct.h>
  36 #include <err.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <pwd.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include "extern.h"
  44 #include "pathnames.h"
  45
  46 static int uid_compare(const DBT *, const DBT *);
  47
  48 static DB       *usracct_db;
  49
  50 int
  51 usracct_init(void)
  52 {
  53         DB *saved_usracct_db;
  54         BTREEINFO bti;
  55         int error;
  56
  57         bzero(&bti, sizeof bti);
  58         bti.compare = uid_compare;
  59
  60         usracct_db = dbopen(NULL, O_RDWR, 0, DB_BTREE, &bti);
  61         if (usracct_db == NULL)
  62                 return (-1);
  63
  64         error = 0;
  65         if (!iflag) {
  66                 DBT key, data;
  67                 int serr, nerr;
  68
  69                 saved_usracct_db = dbopen(_PATH_USRACCT, O_RDONLY, 0, DB_BTREE,
  70                     &bti);
  71                 if (saved_usracct_db == NULL) {
  72                         error = (errno == ENOENT) ? 0 : -1;
  73                         if (error)
  74                                 warn("retrieving user accounting summary");
  75                         goto out;
  76                 }
  77
  78                 serr = DB_SEQ(saved_usracct_db, &key, &data, R_FIRST);
  79                 if (serr < 0) {
  80                         warn("retrieving user accounting summary");
  81                         error = -1;
  82                         goto closeout;
  83                 }
  84                 while (serr == 0) {
  85                         nerr = DB_PUT(usracct_db, &key, &data, 0);
  86                         if (nerr < 0) {
  87                                 warn("initializing user accounting stats");
  88                                 error = -1;
  89                                 break;
  90                         }
  91
  92                         serr = DB_SEQ(saved_usracct_db, &key, &data, R_NEXT);
  93                         if (serr < 0) {
  94                                 warn("retrieving user accounting summary");
  95                                 error = -1;
  96                                 break;
  97                         }
  98                 }
  99
 100 closeout:
 101                 if (DB_CLOSE(saved_usracct_db) < 0) {
 102                         warn("closing user accounting summary");
 103                         error = -1;
 104                 }
 105         }
 106
 107 out:
 108         if (error != 0)
 109                 usracct_destroy();
 110         return (error);
 111 }
 112
 113 void
 114 usracct_destroy(void)
 115 {
 116         if (DB_CLOSE(usracct_db) < 0)
 117                 warn("destroying user accounting stats");
 118 }
 119
 120 int
 121 usracct_add(const struct cmdinfo *ci)
 122 {
 123         DBT key, data;
 124         struct userinfo newui;
 125         u_long uid;
 126         int rv;
 127
 128         uid = ci->ci_uid;
 129         key.data = &uid;
 130         key.size = sizeof uid;
 131
 132         rv = DB_GET(usracct_db, &key, &data, 0);
 133         if (rv < 0) {
 134                 warn("get key %lu from user accounting stats", uid);
 135                 return (-1);
 136         } else if (rv == 0) {   /* it's there; copy whole thing */
 137                 /* add the old data to the new data */
 138                 bcopy(data.data, &newui, data.size);
 139                 if (newui.ui_uid != uid) {
 140                         warnx("key %lu != expected record number %lu",
 141                             newui.ui_uid, uid);
 142                         warnx("inconsistent user accounting stats");
 143                         return (-1);
 144                 }
 145         } else {                /* it's not there; zero it and copy the key */
 146                 bzero(&newui, sizeof newui);
 147                 newui.ui_uid = ci->ci_uid;
 148         }
 149
 150         newui.ui_calls += ci->ci_calls;
 151         newui.ui_utime += ci->ci_utime;
 152         newui.ui_stime += ci->ci_stime;
 153         newui.ui_mem += ci->ci_mem;
 154         newui.ui_io += ci->ci_io;
 155
 156         data.data = &newui;
 157         data.size = sizeof newui;
 158         rv = DB_PUT(usracct_db, &key, &data, 0);
 159         if (rv < 0) {
 160                 warn("add key %lu to user accounting stats", uid);
 161                 return (-1);
 162         } else if (rv != 0) {
 163                 warnx("DB_PUT returned 1");
 164                 return (-1);
 165         }
 166
 167         return (0);
 168 }
 169
 170 int
 171 usracct_update(void)
 172 {
 173         DB *saved_usracct_db;
 174         DBT key, data;
 175         BTREEINFO bti;
 176         int error, serr, nerr;
 177
 178         bzero(&bti, sizeof bti);
 179         bti.compare = uid_compare;
 180
 181         saved_usracct_db = dbopen(_PATH_USRACCT, O_RDWR|O_CREAT|O_TRUNC, 0644,
 182             DB_BTREE, &bti);
 183         if (saved_usracct_db == NULL) {
 184                 warn("creating user accounting summary");
 185                 return (-1);
 186         }
 187
 188         error = 0;
 189
 190         serr = DB_SEQ(usracct_db, &key, &data, R_FIRST);
 191         if (serr < 0) {
 192                 warn("retrieving user accounting stats");
 193                 error = -1;
 194         }
 195         while (serr == 0) {
 196                 nerr = DB_PUT(saved_usracct_db, &key, &data, 0);
 197                 if (nerr < 0) {
 198                         warn("saving user accounting summary");
 199                         error = -1;
 200                         break;
 201                 }
 202
 203                 serr = DB_SEQ(usracct_db, &key, &data, R_NEXT);
 204                 if (serr < 0) {
 205                         warn("retrieving user accounting stats");
 206                         error = -1;
 207                         break;
 208                 }
 209         }
 210
 211         if (DB_SYNC(saved_usracct_db, 0) < 0) {
 212                 warn("syncing process accounting summary");
 213                 error = -1;
 214         }
 215         if (DB_CLOSE(saved_usracct_db) < 0) {
 216                 warn("closing process accounting summary");
 217                 error = -1;
 218         }
 219         return error;
 220 }
 221
 222 void
 223 usracct_print(void)
 224 {
 225         DBT key, data;
 226         struct userinfo uistore, *ui = &uistore;
 227         double t;
 228         int rv;
 229
 230         rv = DB_SEQ(usracct_db, &key, &data, R_FIRST);
 231         if (rv < 0)
 232                 warn("retrieving user accounting stats");
 233
 234         while (rv == 0) {
 235                 memcpy(ui, data.data, sizeof(struct userinfo));
 236
 237                 printf("%-*s %9ju ", MAXLOGNAME - 1,
 238                     user_from_uid(ui->ui_uid, 0), (uintmax_t)ui->ui_calls);
 239
 240                 t = (double) (ui->ui_utime + ui->ui_stime) /
 241                     (double) AHZ;
 242                 if (t < 0.0001)         /* kill divide by zero */
 243                         t = 0.0001;
 244
 245                 printf("%12.2f%s ", t / 60.0, "cpu");
 246
 247                 /* ui->ui_calls is always != 0 */
 248                 if (dflag)
 249                         printf("%12ju%s", (uintmax_t)ui->ui_io / ui->ui_calls,
 250                             "avio");
 251                 else
 252                         printf("%12ju%s", (uintmax_t)ui->ui_io, "tio");
 253
 254                 /* t is always >= 0.0001; see above */
 255                 if (kflag)
 256                         printf("%12.0f%s", ui->ui_mem / t, "k");
 257                 else
 258                         printf("%12ju%s", (uintmax_t)ui->ui_mem, "k*sec");
 259
 260                 printf("\n");
 261
 262                 rv = DB_SEQ(usracct_db, &key, &data, R_NEXT);
 263                 if (rv < 0)
 264                         warn("retrieving user accounting stats");
 265         }
 266 }
 267
 268 static int
 269 uid_compare(const DBT *k1, const DBT *k2)
 270 {
 271         u_long d1, d2;
 272
 273         bcopy(k1->data, &d1, sizeof d1);
 274         bcopy(k2->data, &d2, sizeof d2);
 275
 276         if (d1 < d2)
 277                 return -1;
 278         else if (d1 == d2)
 279                 return 0;
 280         else
 281                 return 1;
 282 }