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 } 283