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

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.