Return to kern_acct.c CVS log

Up to [Apple Darwin 0.x] / kernel / bsd / kern

Annotation of kernel/bsd/kern/kern_acct.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
        !             7:  * Reserved.  This file contains Original Code and/or Modifications of
        !             8:  * Original Code as defined in and that are subject to the Apple Public
        !             9:  * Source License Version 1.1 (the "License").  You may not use this file
        !            10:  * except in compliance with the License.  Please obtain a copy of the
        !            11:  * License at http://www.apple.com/publicsource and read it before using
        !            12:  * this file.
        !            13:  * 
        !            14:  * The Original Code and all software distributed under the License are
        !            15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            19:  * License for the specific language governing rights and limitations
        !            20:  * under the License.
        !            21:  * 
        !            22:  * @APPLE_LICENSE_HEADER_END@
        !            23:  */
        !            24: 
        !            25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
        !            26: /*-
        !            27:  * Copyright (c) 1982, 1986, 1989, 1993
        !            28:  *     The Regents of the University of California.  All rights reserved.
        !            29:  * (c) UNIX System Laboratories, Inc.
        !            30:  * All or some portions of this file are derived from material licensed
        !            31:  * to the University of California by American Telephone and Telegraph
        !            32:  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
        !            33:  * the permission of UNIX System Laboratories, Inc.
        !            34:  *
        !            35:  * Redistribution and use in source and binary forms, with or without
        !            36:  * modification, are permitted provided that the following conditions
        !            37:  * are met:
        !            38:  * 1. Redistributions of source code must retain the above copyright
        !            39:  *    notice, this list of conditions and the following disclaimer.
        !            40:  * 2. Redistributions in binary form must reproduce the above copyright
        !            41:  *    notice, this list of conditions and the following disclaimer in the
        !            42:  *    documentation and/or other materials provided with the distribution.
        !            43:  * 3. All advertising materials mentioning features or use of this software
        !            44:  *    must display the following acknowledgement:
        !            45:  *     This product includes software developed by the University of
        !            46:  *     California, Berkeley and its contributors.
        !            47:  * 4. Neither the name of the University nor the names of its contributors
        !            48:  *    may be used to endorse or promote products derived from this software
        !            49:  *    without specific prior written permission.
        !            50:  *
        !            51:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            52:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            53:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            54:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            55:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            56:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            57:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            58:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            59:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            60:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            61:  * SUCH DAMAGE.
        !            62:  *
        !            63:  *     @(#)kern_acct.c 8.1 (Berkeley) 6/14/93
        !            64:  */
        !            65: /* HISTORY
        !            66:  * 08-May-95  Mac Gillon (mgillon) at NeXT
        !            67:  *     Purged old history
        !            68:  *     New version based on 4.4
        !            69:  */
        !            70: 
        !            71: 
        !            72: #include <sys/param.h>
        !            73: #include <sys/proc.h>
        !            74: #include <sys/mount.h>
        !            75: #include <sys/vnode.h>
        !            76: #include <sys/file.h>
        !            77: #include <sys/syslog.h>
        !            78: #include <sys/kernel.h>
        !            79: #include <sys/namei.h>
        !            80: #include <sys/errno.h>
        !            81: #include <sys/acct.h>
        !            82: #include <sys/resourcevar.h>
        !            83: #include <sys/ioctl.h>
        !            84: #include <sys/tty.h>
        !            85: 
        !            86: /*
        !            87:  * The routines implemented in this file are described in:
        !            88:  *      Leffler, et al.: The Design and Implementation of the 4.3BSD
        !            89:  *         UNIX Operating System (Addison Welley, 1989)
        !            90:  * on pages 62-63.
        !            91:  *
        !            92:  * Arguably, to simplify accounting operations, this mechanism should
        !            93:  * be replaced by one in which an accounting log file (similar to /dev/klog)
        !            94:  * is read by a user process, etc.  However, that has its own problems.
        !            95:  */
        !            96: 
        !            97: /*
        !            98:  * Internal accounting functions.
        !            99:  * The former's operation is described in Leffler, et al., and the latter
        !           100:  * was provided by UCB with the 4.4BSD-Lite release
        !           101:  */
        !           102: comp_t encode_comp_t __P((u_long, u_long));
        !           103: void   acctwatch __P((void *));
        !           104: 
        !           105: /*
        !           106:  * Accounting vnode pointer, and saved vnode pointer.
        !           107:  */
        !           108: struct vnode *acctp;
        !           109: struct vnode *savacctp;
        !           110: 
        !           111: /*
        !           112:  * Values associated with enabling and disabling accounting
        !           113:  */
        !           114: int    acctsuspend = 2;        /* stop accounting when < 2% free space left */
        !           115: int    acctresume = 4;         /* resume when free space risen to > 4% */
        !           116: int    acctchkfreq = 15;       /* frequency (in seconds) to check space */
        !           117: 
        !           118: /*
        !           119:  * Accounting system call.  Written based on the specification and
        !           120:  * previous implementation done by Mark Tinguely.
        !           121:  */
        !           122: struct acct_args {
        !           123:        char    *path;
        !           124: };
        !           125: acct(p, uap, retval)
        !           126:        struct proc *p;
        !           127:        struct acct_args *uap;
        !           128:        int *retval;
        !           129: {
        !           130:        struct nameidata nd;
        !           131:        int error;
        !           132: 
        !           133:        /* Make sure that the caller is root. */
        !           134:        if (error = suser(p->p_ucred, &p->p_acflag))
        !           135:                return (error);
        !           136: 
        !           137:        /*
        !           138:         * If accounting is to be started to a file, open that file for
        !           139:         * writing and make sure it's a 'normal'.
        !           140:         */
        !           141:        if (uap->path != NULL) {
        !           142:                NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_USERSPACE, uap->path, p);
        !           143:                if (error = vn_open(&nd, FWRITE, 0))
        !           144:                        return (error);
        !           145:                VOP_UNLOCK(nd.ni_vp, 0, p);
        !           146:                if (nd.ni_vp->v_type != VREG) {
        !           147:                        vn_close(nd.ni_vp, FWRITE, p->p_ucred, p);
        !           148:                        return (EACCES);
        !           149:                }
        !           150:        }
        !           151: 
        !           152:        /*
        !           153:         * If accounting was previously enabled, kill the old space-watcher,
        !           154:         * close the file, and (if no new file was specified, leave).
        !           155:         */
        !           156:        if (acctp != NULLVP || savacctp != NULLVP) {
        !           157:                untimeout(acctwatch, NULL);
        !           158:                error = vn_close((acctp != NULLVP ? acctp : savacctp), FWRITE,
        !           159:                    p->p_ucred, p);
        !           160:                acctp = savacctp = NULLVP;
        !           161:        }
        !           162:        if (uap->path == NULL)
        !           163:                return (error);
        !           164: 
        !           165:        /*
        !           166:         * Save the new accounting file vnode, and schedule the new
        !           167:         * free space watcher.
        !           168:         */
        !           169:        acctp = nd.ni_vp;
        !           170:        acctwatch(NULL);
        !           171:        return (error);
        !           172: }
        !           173: 
        !           174: /*
        !           175:  * Write out process accounting information, on process exit.
        !           176:  * Data to be written out is specified in Leffler, et al.
        !           177:  * and are enumerated below.  (They're also noted in the system
        !           178:  * "acct.h" header file.)
        !           179:  */
        !           180: acct_process(p)
        !           181:        struct proc *p;
        !           182: {
        !           183:        struct acct acct;
        !           184:        struct rusage *r;
        !           185:        struct timeval ut, st, tmp;
        !           186:        int s, t;
        !           187:        struct vnode *vp;
        !           188: 
        !           189:        /* If accounting isn't enabled, don't bother */
        !           190:        vp = acctp;
        !           191:        if (vp == NULLVP)
        !           192:                return (0);
        !           193: 
        !           194:        /*
        !           195:         * Get process accounting information.
        !           196:         */
        !           197: 
        !           198:        /* (1) The name of the command that ran */
        !           199:        bcopy(p->p_comm, acct.ac_comm, sizeof acct.ac_comm);
        !           200: 
        !           201:        /* (2) The amount of user and system time that was used */
        !           202:        calcru(p, &ut, &st, NULL);
        !           203:        acct.ac_utime = encode_comp_t(ut.tv_sec, ut.tv_usec);
        !           204:        acct.ac_stime = encode_comp_t(st.tv_sec, st.tv_usec);
        !           205: 
        !           206:        /* (3) The elapsed time the commmand ran (and its starting time) */
        !           207:        acct.ac_btime = p->p_stats->p_start.tv_sec;
        !           208:        s = splclock();
        !           209:        tmp = time;
        !           210:        splx(s);
        !           211:        timevalsub(&tmp, &p->p_stats->p_start);
        !           212:        acct.ac_etime = encode_comp_t(tmp.tv_sec, tmp.tv_usec);
        !           213: 
        !           214:        /* (4) The average amount of memory used */
        !           215:        r = &p->p_stats->p_ru;
        !           216:        tmp = ut;
        !           217:        timevaladd(&tmp, &st);
        !           218:        t = tmp.tv_sec * hz + tmp.tv_usec / tick;
        !           219:        if (t)
        !           220:                acct.ac_mem = (r->ru_ixrss + r->ru_idrss + r->ru_isrss) / t;
        !           221:        else
        !           222:                acct.ac_mem = 0;
        !           223: 
        !           224:        /* (5) The number of disk I/O operations done */
        !           225:        acct.ac_io = encode_comp_t(r->ru_inblock + r->ru_oublock, 0);
        !           226: 
        !           227:        /* (6) The UID and GID of the process */
        !           228:        acct.ac_uid = p->p_cred->p_ruid;
        !           229:        acct.ac_gid = p->p_cred->p_rgid;
        !           230: 
        !           231:        /* (7) The terminal from which the process was started */
        !           232:        if ((p->p_flag & P_CONTROLT) && p->p_pgrp->pg_session->s_ttyp)
        !           233:                acct.ac_tty = p->p_pgrp->pg_session->s_ttyp->t_dev;
        !           234:        else
        !           235:                acct.ac_tty = NODEV;
        !           236: 
        !           237:        /* (8) The boolean flags that tell how the process terminated, etc. */
        !           238:        acct.ac_flag = p->p_acflag;
        !           239: 
        !           240:        /*
        !           241:         * Now, just write the accounting information to the file.
        !           242:         */
        !           243:        VOP_LEASE(vp, p, p->p_ucred, LEASE_WRITE);
        !           244:        return (vn_rdwr(UIO_WRITE, vp, (caddr_t)&acct, sizeof (acct),
        !           245:            (off_t)0, UIO_SYSSPACE, IO_APPEND|IO_UNIT, p->p_ucred,
        !           246:            (int *)0, p));
        !           247: }
        !           248: 
        !           249: /*
        !           250:  * Encode_comp_t converts from ticks in seconds and microseconds
        !           251:  * to ticks in 1/AHZ seconds.  The encoding is described in
        !           252:  * Leffler, et al., on page 63.
        !           253:  */
        !           254: 
        !           255: #define        MANTSIZE        13                      /* 13 bit mantissa. */
        !           256: #define        EXPSIZE         3                       /* Base 8 (3 bit) exponent. */
        !           257: #define        MAXFRACT        ((1 << MANTSIZE) - 1)   /* Maximum fractional value. */
        !           258: 
        !           259: comp_t
        !           260: encode_comp_t(s, us)
        !           261:        u_long s, us;
        !           262: {
        !           263:        int exp, rnd;
        !           264: 
        !           265:        exp = 0;
        !           266:        rnd = 0;
        !           267:        s *= AHZ;
        !           268:        s += us / (1000000 / AHZ);      /* Maximize precision. */
        !           269: 
        !           270:        while (s > MAXFRACT) {
        !           271:        rnd = s & (1 << (EXPSIZE - 1)); /* Round up? */
        !           272:                s >>= EXPSIZE;          /* Base 8 exponent == 3 bit shift. */
        !           273:                exp++;
        !           274:        }
        !           275: 
        !           276:        /* If we need to round up, do it (and handle overflow correctly). */
        !           277:        if (rnd && (++s > MAXFRACT)) {
        !           278:                s >>= EXPSIZE;
        !           279:                exp++;
        !           280:        }
        !           281: 
        !           282:        /* Clean it up and polish it off. */
        !           283:        exp <<= MANTSIZE;               /* Shift the exponent into place */
        !           284:        exp += s;                       /* and add on the mantissa. */
        !           285:        return (exp);
        !           286: }
        !           287: 
        !           288: /*
        !           289:  * Periodically check the file system to see if accounting
        !           290:  * should be turned on or off.  Beware the case where the vnode
        !           291:  * has been vgone()'d out from underneath us, e.g. when the file
        !           292:  * system containing the accounting file has been forcibly unmounted.
        !           293:  */
        !           294: /* ARGSUSED */
        !           295: void
        !           296: acctwatch(a)
        !           297:        void *a;
        !           298: {
        !           299:        struct statfs sb;
        !           300: 
        !           301:        if (savacctp != NULLVP) {
        !           302:                if (savacctp->v_type == VBAD) {
        !           303:                        (void) vn_close(savacctp, FWRITE, NOCRED, NULL);
        !           304:                        savacctp = NULLVP;
        !           305:                        return;
        !           306:                }
        !           307:                (void)VFS_STATFS(savacctp->v_mount, &sb, (struct proc *)0);
        !           308:                if (sb.f_bavail > acctresume * sb.f_blocks / 100) {
        !           309:                        acctp = savacctp;
        !           310:                        savacctp = NULLVP;
        !           311:                        log(LOG_NOTICE, "Accounting resumed\n");
        !           312:                }
        !           313:        } else if (acctp != NULLVP) {
        !           314:                if (acctp->v_type == VBAD) {
        !           315:                        (void) vn_close(acctp, FWRITE, NOCRED, NULL);
        !           316:                        acctp = NULLVP;
        !           317:                        return;
        !           318:                }
        !           319:                (void)VFS_STATFS(acctp->v_mount, &sb, (struct proc *)0);
        !           320:                if (sb.f_bavail <= acctsuspend * sb.f_blocks / 100) {
        !           321:                        savacctp = acctp;
        !           322:                        acctp = NULLVP;
        !           323:                        log(LOG_NOTICE, "Accounting suspended\n");
        !           324:                }
        !           325:        } else
        !           326:                return;
        !           327:        timeout(acctwatch, NULL, acctchkfreq * hz);
        !           328: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.