sys/kern/kern_acct.c

   1 /*      $NetBSD: kern_acct.c,v 1.87 2009/02/11 00:32:45 enami Exp $     */
   2
   3 /*-
   4  * Copyright (c) 1982, 1986, 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)kern_acct.c 8.8 (Berkeley) 5/14/95
  37  */
  38
  39 /*-
  40  * Copyright (c) 1994 Christopher G. Demetriou
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. All advertising materials mentioning features or use of this software
  51  *    must display the following acknowledgement:
  52  *      This product includes software developed by the University of
  53  *      California, Berkeley and its contributors.
  54  * 4. Neither the name of the University nor the names of its contributors
  55  *    may be used to endorse or promote products derived from this software
  56  *    without specific prior written permission.
  57  *
  58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  68  * SUCH DAMAGE.
  69  *
  70  *      @(#)kern_acct.c 8.8 (Berkeley) 5/14/95
  71  */
  72
  73 #include <sys/cdefs.h>
  74 __KERNEL_RCSID(0, "$NetBSD: kern_acct.c,v 1.87 2009/02/11 00:32:45 enami Exp $");
  75
  76 #include <sys/param.h>
  77 #include <sys/systm.h>
  78 #include <sys/proc.h>
  79 #include <sys/mount.h>
  80 #include <sys/vnode.h>
  81 #include <sys/file.h>
  82 #include <sys/syslog.h>
  83 #include <sys/kernel.h>
  84 #include <sys/kthread.h>
  85 #include <sys/kmem.h>
  86 #include <sys/namei.h>
  87 #include <sys/errno.h>
  88 #include <sys/acct.h>
  89 #include <sys/resourcevar.h>
  90 #include <sys/ioctl.h>
  91 #include <sys/tty.h>
  92 #include <sys/kauth.h>
  93
  94 #include <sys/syscallargs.h>
  95
  96 /*
  97  * The routines implemented in this file are described in:
  98  *      Leffler, et al.: The Design and Implementation of the 4.3BSD
  99  *          UNIX Operating System (Addison Welley, 1989)
 100  * on pages 62-63.
 101  *
 102  * Arguably, to simplify accounting operations, this mechanism should
 103  * be replaced by one in which an accounting log file (similar to /dev/klog)
 104  * is read by a user process, etc.  However, that has its own problems.
 105  */
 106
 107 /*
 108  * Lock to serialize system calls and kernel threads.
 109  */
 110 krwlock_t       acct_lock;
 111
 112 /*
 113  * The global accounting state and related data.  Gain the mutex before
 114  * accessing these variables.
 115  */
 116 static enum {
 117         ACCT_STOP,
 118         ACCT_ACTIVE,
 119         ACCT_SUSPENDED
 120 } acct_state;                           /* The current accounting state. */
 121 static struct vnode *acct_vp;           /* Accounting vnode pointer. */
 122 static kauth_cred_t acct_cred;          /* Credential of accounting file
 123                                            owner (i.e root).  Used when
 124                                            accounting file i/o.  */
 125 static struct lwp *acct_dkwatcher;      /* Free disk space checker. */
 126
 127 /*
 128  * Values associated with enabling and disabling accounting
 129  */
 130 int     acctsuspend = 2;        /* stop accounting when < 2% free space left */
 131 int     acctresume = 4;         /* resume when free space risen to > 4% */
 132 int     acctchkfreq = 15;       /* frequency (in seconds) to check space */
 133
 134 /*
 135  * Encode_comp_t converts from ticks in seconds and microseconds
 136  * to ticks in 1/AHZ seconds.  The encoding is described in
 137  * Leffler, et al., on page 63.
 138  */
 139
 140 #define MANTSIZE        13                      /* 13 bit mantissa. */
 141 #define EXPSIZE         3                       /* Base 8 (3 bit) exponent. */
 142 #define MAXFRACT        ((1 << MANTSIZE) - 1)   /* Maximum fractional value. */
 143
 144 static comp_t
 145 encode_comp_t(u_long s, u_long us)
 146 {
 147         int exp, rnd;
 148
 149         exp = 0;
 150         rnd = 0;
 151         s *= AHZ;
 152         s += us / (1000000 / AHZ);      /* Maximize precision. */
 153
 154         while (s > MAXFRACT) {
 155         rnd = s & (1 << (EXPSIZE - 1)); /* Round up? */
 156                 s >>= EXPSIZE;          /* Base 8 exponent == 3 bit shift. */
 157                 exp++;
 158         }
 159
 160         /* If we need to round up, do it (and handle overflow correctly). */
 161         if (rnd && (++s > MAXFRACT)) {
 162                 s >>= EXPSIZE;
 163                 exp++;
 164         }
 165
 166         /* Clean it up and polish it off. */
 167         exp <<= MANTSIZE;               /* Shift the exponent into place */
 168         exp += s;                       /* and add on the mantissa. */
 169         return (exp);
 170 }
 171
 172 static int
 173 acct_chkfree(void)
 174 {
 175         int error;
 176         struct statvfs *sb;
 177         int64_t bavail;
 178
 179         sb = kmem_alloc(sizeof(*sb), KM_SLEEP);
 180         if (sb == NULL)
 181                 return (ENOMEM);
 182         error = VFS_STATVFS(acct_vp->v_mount, sb);
 183         if (error != 0) {
 184                 kmem_free(sb, sizeof(*sb));
 185                 return (error);
 186         }
 187
 188         bavail = sb->f_bfree - sb->f_bresvd;
 189
 190         switch (acct_state) {
 191         case ACCT_SUSPENDED:
 192                 if (bavail > acctresume * sb->f_blocks / 100) {
 193                         acct_state = ACCT_ACTIVE;
 194                         log(LOG_NOTICE, "Accounting resumed\n");
 195                 }
 196                 break;
 197         case ACCT_ACTIVE:
 198                 if (bavail <= acctsuspend * sb->f_blocks / 100) {
 199                         acct_state = ACCT_SUSPENDED;
 200                         log(LOG_NOTICE, "Accounting suspended\n");
 201                 }
 202                 break;
 203         case ACCT_STOP:
 204                 break;
 205         }
 206         kmem_free(sb, sizeof(*sb));
 207         return (0);
 208 }
 209
 210 static void
 211 acct_stop(void)
 212 {
 213         int error;
 214
 215         KASSERT(rw_write_held(&acct_lock));
 216
 217         if (acct_vp != NULLVP && acct_vp->v_type != VBAD) {
 218                 error = vn_close(acct_vp, FWRITE, acct_cred);
 219 #ifdef DIAGNOSTIC
 220                 if (error != 0)
 221                         printf("acct_stop: failed to close, errno = %d\n",
 222                             error);
 223 #endif
 224                 acct_vp = NULLVP;
 225         }
 226         if (acct_cred != NULL) {
 227                 kauth_cred_free(acct_cred);
 228                 acct_cred = NULL;
 229         }
 230         acct_state = ACCT_STOP;
 231 }
 232
 233 /*
 234  * Periodically check the file system to see if accounting
 235  * should be turned on or off.  Beware the case where the vnode
 236  * has been vgone()'d out from underneath us, e.g. when the file
 237  * system containing the accounting file has been forcibly unmounted.
 238  */
 239 static void
 240 acctwatch(void *arg)
 241 {
 242         int error;
 243
 244         log(LOG_NOTICE, "Accounting started\n");
 245         rw_enter(&acct_lock, RW_WRITER);
 246         while (acct_state != ACCT_STOP) {
 247                 if (acct_vp->v_type == VBAD) {
 248                         log(LOG_NOTICE, "Accounting terminated\n");
 249                         acct_stop();
 250                         continue;
 251                 }
 252
 253                 error = acct_chkfree();
 254 #ifdef DIAGNOSTIC
 255                 if (error != 0)
 256                         printf("acctwatch: failed to statvfs, error = %d\n",
 257                             error);
 258 #endif
 259                 rw_exit(&acct_lock);
 260                 error = kpause("actwat", false, acctchkfreq * hz, NULL);
 261                 rw_enter(&acct_lock, RW_WRITER);
 262 #ifdef DIAGNOSTIC
 263                 if (error != 0 && error != EWOULDBLOCK)
 264                         printf("acctwatch: sleep error %d\n", error);
 265 #endif
 266         }
 267         acct_dkwatcher = NULL;
 268         rw_exit(&acct_lock);
 269
 270         kthread_exit(0);
 271 }
 272
 273 void
 274 acct_init(void)
 275 {
 276
 277         acct_state = ACCT_STOP;
 278         acct_vp = NULLVP;
 279         acct_cred = NULL;
 280         rw_init(&acct_lock);
 281 }
 282
 283 /*
 284  * Accounting system call.  Written based on the specification and
 285  * previous implementation done by Mark Tinguely.
 286  */
 287 int
 288 sys_acct(struct lwp *l, const struct sys_acct_args *uap, register_t *retval)
 289 {
 290         /* {
 291                 syscallarg(const char *) path;
 292         } */
 293         struct nameidata nd;
 294         int error;
 295
 296         /* Make sure that the caller is root. */
 297         if ((error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_ACCOUNTING,
 298             0, NULL, NULL, NULL)))
 299                 return (error);
 300
 301         /*
 302          * If accounting is to be started to a file, open that file for
 303          * writing and make sure it's a 'normal'.
 304          */
 305         if (SCARG(uap, path) != NULL) {
 306                 struct vattr va;
 307                 size_t pad;
 308                 NDINIT(&nd, LOOKUP, FOLLOW | TRYEMULROOT, UIO_USERSPACE,
 309                     SCARG(uap, path));
 310                 if ((error = vn_open(&nd, FWRITE|O_APPEND, 0)) != 0)
 311                         return (error);
 312                 if (nd.ni_vp->v_type != VREG) {
 313                         VOP_UNLOCK(nd.ni_vp, 0);
 314                         error = EACCES;
 315                         goto bad;
 316                 }
 317                 if ((error = VOP_GETATTR(nd.ni_vp, &va, l->l_cred)) != 0) {
 318                         VOP_UNLOCK(nd.ni_vp, 0);
 319                         goto bad;
 320                 }
 321
 322                 if ((pad = (va.va_size % sizeof(struct acct))) != 0) {
 323                         u_quad_t size = va.va_size - pad;
 324 #ifdef DIAGNOSTIC
 325                         printf("Size of accounting file not a multiple of "
 326                             "%lu - incomplete record truncated\n",
 327                             (unsigned long)sizeof(struct acct));
 328 #endif
 329                         vattr_null(&va);
 330                         va.va_size = size;
 331                         error = VOP_SETATTR(nd.ni_vp, &va, l->l_cred);
 332                         if (error != 0) {
 333                                 VOP_UNLOCK(nd.ni_vp, 0);
 334                                 goto bad;
 335                         }
 336                 }
 337                 VOP_UNLOCK(nd.ni_vp, 0);
 338         }
 339
 340         rw_enter(&acct_lock, RW_WRITER);
 341
 342         /*
 343          * If accounting was previously enabled, kill the old space-watcher,
 344          * free credential for accounting file i/o,
 345          * ... (and, if no new file was specified, leave).
 346          */
 347         acct_stop();
 348         if (SCARG(uap, path) == NULL)
 349                 goto out;
 350
 351         /*
 352          * Save the new accounting file vnode and credential,
 353          * and schedule the new free space watcher.
 354          */
 355         acct_state = ACCT_ACTIVE;
 356         acct_vp = nd.ni_vp;
 357         acct_cred = l->l_cred;
 358         kauth_cred_hold(acct_cred);
 359
 360         error = acct_chkfree();         /* Initial guess. */
 361         if (error != 0) {
 362                 acct_stop();
 363                 goto out;
 364         }
 365
 366         if (acct_dkwatcher == NULL) {
 367                 error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
 368                     acctwatch, NULL, &acct_dkwatcher, "acctwatch");
 369                 if (error != 0)
 370                         acct_stop();
 371         }
 372
 373  out:
 374         rw_exit(&acct_lock);
 375         return (error);
 376  bad:
 377         vn_close(nd.ni_vp, FWRITE, l->l_cred);
 378         return error;
 379 }
 380
 381 /*
 382  * Write out process accounting information, on process exit.
 383  * Data to be written out is specified in Leffler, et al.
 384  * and are enumerated below.  (They're also noted in the system
 385  * "acct.h" header file.)
 386  */
 387 int
 388 acct_process(struct lwp *l)
 389 {
 390         struct acct acct;
 391         struct timeval ut, st, tmp;
 392         struct rusage *r;
 393         int t, error = 0;
 394         struct rlimit orlim;
 395         struct proc *p = l->l_proc;
 396
 397         if (acct_state != ACCT_ACTIVE)
 398                 return 0;
 399
 400         rw_enter(&acct_lock, RW_READER);
 401
 402         /* If accounting isn't enabled, don't bother */
 403         if (acct_state != ACCT_ACTIVE)
 404                 goto out;
 405
 406         /*
 407          * Temporarily raise the file limit so that accounting can't
 408          * be stopped by the user.
 409          *
 410          * XXX We should think about the CPU limit, too.
 411          */
 412         lim_privatise(p, false);
 413         orlim = p->p_rlimit[RLIMIT_FSIZE];
 414         /* Set current and max to avoid illegal values */
 415         p->p_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
 416         p->p_rlimit[RLIMIT_FSIZE].rlim_max = RLIM_INFINITY;
 417
 418         /*
 419          * Get process accounting information.
 420          */
 421
 422         /* (1) The name of the command that ran */
 423         memcpy(acct.ac_comm, p->p_comm, sizeof(acct.ac_comm));
 424
 425         /* (2) The amount of user and system time that was used */
 426         mutex_enter(p->p_lock);
 427         calcru(p, &ut, &st, NULL, NULL);
 428         mutex_exit(p->p_lock);
 429         acct.ac_utime = encode_comp_t(ut.tv_sec, ut.tv_usec);
 430         acct.ac_stime = encode_comp_t(st.tv_sec, st.tv_usec);
 431
 432         /* (3) The elapsed time the commmand ran (and its starting time) */
 433         acct.ac_btime = p->p_stats->p_start.tv_sec;
 434         getmicrotime(&tmp);
 435         timersub(&tmp, &p->p_stats->p_start, &tmp);
 436         acct.ac_etime = encode_comp_t(tmp.tv_sec, tmp.tv_usec);
 437
 438         /* (4) The average amount of memory used */
 439         r = &p->p_stats->p_ru;
 440         timeradd(&ut, &st, &tmp);
 441         t = tmp.tv_sec * hz + tmp.tv_usec / tick;
 442         if (t)
 443                 acct.ac_mem = (r->ru_ixrss + r->ru_idrss + r->ru_isrss) / t;
 444         else
 445                 acct.ac_mem = 0;
 446
 447         /* (5) The number of disk I/O operations done */
 448         acct.ac_io = encode_comp_t(r->ru_inblock + r->ru_oublock, 0);
 449
 450         /* (6) The UID and GID of the process */
 451         acct.ac_uid = kauth_cred_getuid(l->l_cred);
 452         acct.ac_gid = kauth_cred_getgid(l->l_cred);
 453
 454         /* (7) The terminal from which the process was started */
 455         mutex_enter(proc_lock);
 456         if ((p->p_lflag & PL_CONTROLT) && p->p_pgrp->pg_session->s_ttyp)
 457                 acct.ac_tty = p->p_pgrp->pg_session->s_ttyp->t_dev;
 458         else
 459                 acct.ac_tty = NODEV;
 460         mutex_exit(proc_lock);
 461
 462         /* (8) The boolean flags that tell how the process terminated, etc. */
 463         acct.ac_flag = p->p_acflag;
 464
 465         /*
 466          * Now, just write the accounting information to the file.
 467          */
 468         error = vn_rdwr(UIO_WRITE, acct_vp, (void *)&acct,
 469             sizeof(acct), (off_t)0, UIO_SYSSPACE, IO_APPEND|IO_UNIT,
 470             acct_cred, NULL, NULL);
 471         if (error != 0)
 472                 log(LOG_ERR, "Accounting: write failed %d\n", error);
 473
 474         /* Restore limit - rather pointless since process is about to exit */
 475         p->p_rlimit[RLIMIT_FSIZE] = orlim;
 476
 477  out:
 478         rw_exit(&acct_lock);
 479         return (error);
 480 }