Return to vtimes.c CVS log

Up to [CSRG BSD Unix] / 42BSD / lib / libc / compat-4.1

Annotation of 42BSD/lib/libc/compat-4.1/vtimes.c, revision 1.1

1.1     ! root        1: /*     vtimes.c        4.1     83/05/31        */
        !             2: 
        !             3: #include <sys/time.h>
        !             4: #include <sys/resource.h>
        !             5: 
        !             6: /*
        !             7:  * Backwards compatible vtimes.
        !             8:  */
        !             9: struct vtimes {
        !            10:        int     vm_utime;               /* user time (60'ths) */
        !            11:        int     vm_stime;               /* system time (60'ths) */
        !            12:        /* divide next two by utime+stime to get averages */
        !            13:        unsigned vm_idsrss;             /* integral of d+s rss */
        !            14:        unsigned vm_ixrss;              /* integral of text rss */
        !            15:        int     vm_maxrss;              /* maximum rss */
        !            16:        int     vm_majflt;              /* major page faults */
        !            17:        int     vm_minflt;              /* minor page faults */
        !            18:        int     vm_nswap;               /* number of swaps */
        !            19:        int     vm_inblk;               /* block reads */
        !            20:        int     vm_oublk;               /* block writes */
        !            21: };
        !            22: 
        !            23: vtimes(par, chi)
        !            24:        register struct vtimes *par, *chi;
        !            25: {
        !            26:        struct rusage ru;
        !            27: 
        !            28:        if (par) {
        !            29:                if (getrusage(RUSAGE_SELF, &ru) < 0)
        !            30:                        return (-1);
        !            31:                getvtimes(&ru, par);
        !            32:        }
        !            33:        if (chi) {
        !            34:                if (getrusage(RUSAGE_CHILDREN, &ru) < 0)
        !            35:                        return (-1);
        !            36:                getvtimes(&ru, chi);
        !            37:        }
        !            38:        return (0);
        !            39: }
        !            40: 
        !            41: static
        !            42: getvtimes(aru, avt)
        !            43:        register struct rusage *aru;
        !            44:        register struct vtimes *avt;
        !            45: {
        !            46: 
        !            47:        avt->vm_utime = scale60(&aru->ru_utime);
        !            48:        avt->vm_stime = scale60(&aru->ru_stime);
        !            49:        avt->vm_idsrss = ((aru->ru_idrss+aru->ru_isrss) / 100) * 60;
        !            50:        avt->vm_ixrss = aru->ru_ixrss / 100 * 60;
        !            51:        avt->vm_maxrss = aru->ru_maxrss;
        !            52:        avt->vm_majflt = aru->ru_majflt;
        !            53:        avt->vm_minflt = aru->ru_minflt;
        !            54:        avt->vm_nswap = aru->ru_nswap;
        !            55:        avt->vm_inblk = aru->ru_inblock;
        !            56:        avt->vm_oublk = aru->ru_oublock;
        !            57: }
        !            58: 
        !            59: static
        !            60: scale60(tvp)
        !            61:        register struct timeval *tvp;
        !            62: {
        !            63: 
        !            64:        return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
        !            65: }

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