usr.sbin/sa/usrdb.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 1994 Christopher G. Demetriou
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Christopher G. Demetriou.
  18  * 4. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/types.h>
  38 #include <sys/acct.h>
  39 #include <err.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <pwd.h>
  43 #include <stdint.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include "extern.h"
  48 #include "pathnames.h"
  49
  50 static int uid_compare(const DBT *, const DBT *);
  51
  52 static DB       *usracct_db;
  53
  54 /* Legacy format in AHZV1 units. */
  55 struct userinfov1 {
  56         uid_t           ui_uid;                 /* user id; for consistency */
  57         u_quad_t        ui_calls;               /* number of invocations */
  58         u_quad_t        ui_utime;               /* user time */
  59         u_quad_t        ui_stime;               /* system time */
  60         u_quad_t        ui_mem;                 /* memory use */
  61         u_quad_t        ui_io;                  /* number of disk i/o ops */
  62 };
  63
  64 /*
  65  * Convert a v1 data record into the current version.
  66  * Return 0 if OK, -1 on error, setting errno.
  67  */
  68 static int
  69 v1_to_v2(DBT *key, DBT *data)
  70 {
  71         struct userinfov1 uiv1;
  72         static struct userinfo uiv2;
  73         static uid_t uid;
  74
  75         if (key->size != sizeof(u_long) || data->size != sizeof(uiv1)) {
  76                 errno = EFTYPE;
  77                 return (-1);
  78         }
  79
  80         /* Convert key. */
  81         key->size = sizeof(uid_t);
  82         uid = (uid_t)*(u_long *)(key->data);
  83         key->data = &uid;
  84
  85         /* Convert data. */
  86         memcpy(&uiv1, data->data, data->size);
  87         memset(&uiv2, 0, sizeof(uiv2));
  88         uiv2.ui_uid = uiv1.ui_uid;
  89         uiv2.ui_calls = uiv1.ui_calls;
  90         uiv2.ui_utime = ((double)uiv1.ui_utime / AHZV1) * 1000000;
  91         uiv2.ui_stime = ((double)uiv1.ui_stime / AHZV1) * 1000000;
  92         uiv2.ui_mem = uiv1.ui_mem;
  93         uiv2.ui_io = uiv1.ui_io;
  94         data->size = sizeof(uiv2);
  95         data->data = &uiv2;
  96
  97         return (0);
  98 }
  99
 100 /* Copy usrdb_file to in-memory usracct_db. */
 101 int
 102 usracct_init(void)
 103 {
 104         BTREEINFO bti;
 105
 106         bzero(&bti, sizeof bti);
 107         bti.compare = uid_compare;
 108
 109         return (db_copy_in(&usracct_db, usrdb_file, "user accounting",
 110             &bti, v1_to_v2));
 111 }
 112
 113 void
 114 usracct_destroy(void)
 115 {
 116         db_destroy(usracct_db, "user accounting");
 117 }
 118
 119 int
 120 usracct_add(const struct cmdinfo *ci)
 121 {
 122         DBT key, data;
 123         struct userinfo newui;
 124         uid_t uid;
 125         int rv;
 126
 127         uid = ci->ci_uid;
 128         key.data = &uid;
 129         key.size = sizeof uid;
 130
 131         rv = DB_GET(usracct_db, &key, &data, 0);
 132         if (rv < 0) {
 133                 warn("get key %u from user accounting stats", uid);
 134                 return (-1);
 135         } else if (rv == 0) {   /* it's there; copy whole thing */
 136                 /* add the old data to the new data */
 137                 bcopy(data.data, &newui, data.size);
 138                 if (newui.ui_uid != uid) {
 139                         warnx("key %u != expected record number %u",
 140                             newui.ui_uid, uid);
 141                         warnx("inconsistent user accounting stats");
 142                         return (-1);
 143                 }
 144         } else {                /* it's not there; zero it and copy the key */
 145                 bzero(&newui, sizeof newui);
 146                 newui.ui_uid = ci->ci_uid;
 147         }
 148
 149         newui.ui_calls += ci->ci_calls;
 150         newui.ui_utime += ci->ci_utime;
 151         newui.ui_stime += ci->ci_stime;
 152         newui.ui_mem += ci->ci_mem;
 153         newui.ui_io += ci->ci_io;
 154
 155         data.data = &newui;
 156         data.size = sizeof newui;
 157         rv = DB_PUT(usracct_db, &key, &data, 0);
 158         if (rv < 0) {
 159                 warn("add key %u to user accounting stats", uid);
 160                 return (-1);
 161         } else if (rv != 0) {
 162                 warnx("DB_PUT returned 1");
 163                 return (-1);
 164         }
 165
 166         return (0);
 167 }
 168
 169 /* Copy in-memory usracct_db to usrdb_file. */
 170 int
 171 usracct_update(void)
 172 {
 173         BTREEINFO bti;
 174
 175         bzero(&bti, sizeof bti);
 176         bti.compare = uid_compare;
 177
 178         return (db_copy_out(usracct_db, usrdb_file, "user accounting",
 179             &bti));
 180 }
 181
 182 void
 183 usracct_print(void)
 184 {
 185         DBT key, data;
 186         struct userinfo uistore, *ui = &uistore;
 187         double t;
 188         int rv;
 189
 190         rv = DB_SEQ(usracct_db, &key, &data, R_FIRST);
 191         if (rv < 0)
 192                 warn("retrieving user accounting stats");
 193
 194         while (rv == 0) {
 195                 memcpy(ui, data.data, sizeof(struct userinfo));
 196
 197                 printf("%-*s %9ju ", MAXLOGNAME - 1,
 198                     user_from_uid(ui->ui_uid, 0), (uintmax_t)ui->ui_calls);
 199
 200                 t = (ui->ui_utime + ui->ui_stime) / 1000000;
 201                 if (t < 0.000001)               /* kill divide by zero */
 202                         t = 0.000001;
 203
 204                 printf("%12.2f%s ", t / 60.0, "cpu");
 205
 206                 /* ui->ui_calls is always != 0 */
 207                 if (dflag)
 208                         printf("%12.0f%s",
 209                             ui->ui_io / ui->ui_calls, "avio");
 210                 else
 211                         printf("%12.0f%s", ui->ui_io, "tio");
 212
 213                 /* t is always >= 0.000001; see above. */
 214                 if (kflag)
 215                         printf("%12.0f%s", ui->ui_mem / t, "k");
 216                 else
 217                         printf("%12.0f%s", ui->ui_mem, "k*sec");
 218
 219                 printf("\n");
 220
 221                 rv = DB_SEQ(usracct_db, &key, &data, R_NEXT);
 222                 if (rv < 0)
 223                         warn("retrieving user accounting stats");
 224         }
 225 }
 226
 227 static int
 228 uid_compare(const DBT *k1, const DBT *k2)
 229 {
 230         uid_t d1, d2;
 231
 232         bcopy(k1->data, &d1, sizeof d1);
 233         bcopy(k2->data, &d2, sizeof d2);
 234
 235         if (d1 < d2)
 236                 return -1;
 237         else if (d1 == d2)
 238                 return 0;
 239         else
 240                 return 1;
 241 }