Return to acct.c CVS log

Up to [Research Unix] / researchv10no / sys / os

Annotation of researchv10no/sys/os/acct.c, revision 1.1.1.1

1.1       root        1: /*     acct.c  4.4     81/03/08        */
                      2: 
                      3: #include "sys/param.h"
                      4: #include "sys/systm.h"
                      5: #include "sys/acct.h"
                      6: #include "sys/user.h"
                      7: #include "sys/inode.h"
                      8: 
                      9: struct inode *acctp;
                     10: 
                     11: /*
                     12:  * Perform process accounting functions.
                     13:  */
                     14: sysacct()
                     15: {
                     16:        register struct inode *ip;
                     17:        register struct a {
                     18:                char    *fname;
                     19:        } *uap;
                     20: 
                     21:        uap = (struct a *)u.u_ap;
                     22:        if (suser() == 0)
                     23:                return;
                     24:        if (uap->fname==NULL) {
                     25:                if (ip = acctp) {
                     26:                        plock(ip);
                     27:                        iput(ip);
                     28:                        acctp = NULL;
                     29:                }
                     30:                return;
                     31:        }
                     32:        if (acctp) {
                     33:                u.u_error = EBUSY;
                     34:                return;
                     35:        }
                     36:        ip = namei(uap->fname, SEGUDATA, &nilargnamei, 1);
                     37:        if(ip == NULL)
                     38:                return;
                     39:        if((ip->i_mode & IFMT) != IFREG) {
                     40:                u.u_error = EACCES;
                     41:                iput(ip);
                     42:                return;
                     43:        }
                     44:        if (access(ip, IWRITE)) {
                     45:                iput(ip);
                     46:                return;
                     47:        }
                     48:        acctp = ip;
                     49:        prele(ip);
                     50: }
                     51: 
                     52: struct acct acctbuf;
                     53: /*
                     54:  * On exit, write a record on the accounting file.
                     55:  */
                     56: acct()
                     57: {
                     58:        register i;
                     59:        register struct inode *ip;
                     60:        off_t siz;
                     61:        register struct acct *ap = &acctbuf;
                     62: 
                     63:        if ((ip=acctp)==NULL)
                     64:                return;
                     65:        plock(ip);
                     66:        for (i=0; i<sizeof(ap->ac_comm); i++)
                     67:                ap->ac_comm[i] = u.u_comm[i];
                     68:        ap->ac_utime = compress((long)u.u_vm.vm_utime);
                     69:        ap->ac_stime = compress((long)u.u_vm.vm_stime);
                     70:        ap->ac_etime = compress((long)(time - u.u_start));
                     71:        ap->ac_btime = u.u_start;
                     72:        ap->ac_uid = u.u_ruid;
                     73:        ap->ac_gid = u.u_rgid;
                     74:        ap->ac_mem = 0;
                     75:        if (i = u.u_vm.vm_utime + u.u_vm.vm_stime)
                     76:                ap->ac_mem = (u.u_vm.vm_ixrss + u.u_vm.vm_idsrss) / i;
                     77:        ap->ac_io = compress((long)(u.u_vm.vm_inblk + u.u_vm.vm_oublk));
                     78:        ap->ac_tty = u.u_ttyino;
                     79:        ap->ac_flag = u.u_acflag;
                     80:        siz = ip->i_size;
                     81:        u.u_offset = ltoL(siz);
                     82:        u.u_base = (caddr_t)ap;
                     83:        u.u_count = sizeof(acctbuf);
                     84:        u.u_segflg = SEGSYS;
                     85:        u.u_error = 0;
                     86:        writei(ip);
                     87:        if(u.u_error)
                     88:                ip->i_size = siz;
                     89:        prele(ip);
                     90: }
                     91: 
                     92: /*
                     93:  * Produce a pseudo-floating point representation
                     94:  * with 3 bits base-8 exponent, 13 bits fraction.
                     95:  */
                     96: compress(t)
                     97: register long t;
                     98: {
                     99:        register exp = 0, round = 0;
                    100: 
                    101:        while (t >= 8192) {
                    102:                exp++;
                    103:                round = t&04;
                    104:                t >>= 3;
                    105:        }
                    106:        if (round) {
                    107:                t++;
                    108:                if (t >= 8192) {
                    109:                        t >>= 3;
                    110:                        exp++;
                    111:                }
                    112:        }
                    113:        return((exp<<13) + t);
                    114: }

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