bin/csh/time.c

   1 /* $NetBSD: time.c,v 1.20 2013/07/16 17:47:43 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1980, 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 #if 0
  35 static char sccsid[] = "@(#)time.c      8.1 (Berkeley) 5/31/93";
  36 #else
  37 __RCSID("$NetBSD: time.c,v 1.20 2013/07/16 17:47:43 christos Exp $");
  38 #endif
  39 #endif /* not lint */
  40
  41 #ifndef NOT_CSH
  42 #include <sys/types.h>
  43 #include <stdarg.h>
  44 #include "csh.h"
  45 #include "extern.h"
  46 #endif
  47 #include <util.h>
  48
  49 /*
  50  * C Shell - routines handling process timing and niceing
  51  */
  52 static void pdeltat(FILE *, struct timeval *, struct timeval *);
  53 static void pcsecs(FILE *, long);
  54
  55 #ifndef NOT_CSH
  56 void
  57 settimes(void)
  58 {
  59     struct rusage ruch;
  60
  61     (void)clock_gettime(CLOCK_MONOTONIC, &time0);
  62     (void)getrusage(RUSAGE_SELF, &ru0);
  63     (void)getrusage(RUSAGE_CHILDREN, &ruch);
  64     ruadd(&ru0, &ruch);
  65 }
  66
  67 /*
  68  * dotime is only called if it is truly a builtin function and not a
  69  * prefix to another command
  70  */
  71 void
  72 /*ARGSUSED*/
  73 dotime(Char **v, struct command *t)
  74 {
  75     struct rusage ru1, ruch;
  76     struct timespec timedol;
  77
  78     (void)getrusage(RUSAGE_SELF, &ru1);
  79     (void)getrusage(RUSAGE_CHILDREN, &ruch);
  80     ruadd(&ru1, &ruch);
  81     (void)clock_gettime(CLOCK_MONOTONIC, &timedol);
  82     prusage(cshout, &ru0, &ru1, &timedol, &time0);
  83 }
  84
  85 /*
  86  * donice is only called when it on the line by itself or with a +- value
  87  */
  88 void
  89 /*ARGSUSED*/
  90 donice(Char **v, struct command *t)
  91 {
  92     Char *cp;
  93     int nval;
  94
  95     nval = 0;
  96     v++;
  97     cp = *v++;
  98     if (cp == 0)
  99         nval = 4;
 100     else if (*v == 0 && any("+-", cp[0]))
 101         nval = getn(cp);
 102     (void)setpriority(PRIO_PROCESS, 0, nval);
 103 }
 104
 105 void
 106 ruadd(struct rusage *ru, struct rusage *ru2)
 107 {
 108     timeradd(&ru->ru_utime, &ru2->ru_utime, &ru->ru_utime);
 109     timeradd(&ru->ru_stime, &ru2->ru_stime, &ru->ru_stime);
 110     if (ru2->ru_maxrss > ru->ru_maxrss)
 111         ru->ru_maxrss = ru2->ru_maxrss;
 112
 113     ru->ru_ixrss += ru2->ru_ixrss;
 114     ru->ru_idrss += ru2->ru_idrss;
 115     ru->ru_isrss += ru2->ru_isrss;
 116     ru->ru_minflt += ru2->ru_minflt;
 117     ru->ru_majflt += ru2->ru_majflt;
 118     ru->ru_nswap += ru2->ru_nswap;
 119     ru->ru_inblock += ru2->ru_inblock;
 120     ru->ru_oublock += ru2->ru_oublock;
 121     ru->ru_msgsnd += ru2->ru_msgsnd;
 122     ru->ru_msgrcv += ru2->ru_msgrcv;
 123     ru->ru_nsignals += ru2->ru_nsignals;
 124     ru->ru_nvcsw += ru2->ru_nvcsw;
 125     ru->ru_nivcsw += ru2->ru_nivcsw;
 126 }
 127 #endif /* NOT_CSH */
 128
 129 void
 130 prusage(FILE *fp, struct rusage *r0, struct rusage *r1, struct timespec *e,
 131         struct timespec *b)
 132 {
 133 #ifndef NOT_CSH
 134     struct varent *vp;
 135 #endif
 136     const char *cp;
 137     long i;
 138     time_t t;
 139     time_t ms;
 140
 141     cp = "%Uu %Ss %E %P %X+%Dk %I+%Oio %Fpf+%Ww";
 142     ms = (e->tv_sec - b->tv_sec) * 100 + (e->tv_nsec - b->tv_nsec) / 10000000;
 143     t = (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 100 +
 144         (r1->ru_utime.tv_usec - r0->ru_utime.tv_usec) / 10000 +
 145         (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 100 +
 146         (r1->ru_stime.tv_usec - r0->ru_stime.tv_usec) / 10000;
 147 #ifndef NOT_CSH
 148     vp = adrof(STRtime);
 149
 150     if (vp && vp->vec[0] && vp->vec[1])
 151         cp = short2str(vp->vec[1]);
 152 #endif
 153
 154     for (; *cp; cp++)
 155         if (*cp != '%')
 156             (void) fputc(*cp, fp);
 157         else if (cp[1])
 158             switch (*++cp) {
 159             case 'D':           /* (average) unshared data size */
 160                 (void)fprintf(fp, "%ld", t == 0 ? 0L :
 161                         (long)((r1->ru_idrss + r1->ru_isrss -
 162                          (r0->ru_idrss + r0->ru_isrss)) / t));
 163                 break;
 164             case 'E':           /* elapsed (wall-clock) time */
 165                 pcsecs(fp, (long) ms);
 166                 break;
 167             case 'F':           /* page faults */
 168                 (void)fprintf(fp, "%ld", r1->ru_majflt - r0->ru_majflt);
 169                 break;
 170             case 'I':           /* FS blocks in */
 171                 (void)fprintf(fp, "%ld", r1->ru_inblock - r0->ru_inblock);
 172                 break;
 173             case 'K':           /* (average) total data memory used  */
 174                 (void)fprintf(fp, "%ld", t == 0 ? 0L :
 175                         (long)(((r1->ru_ixrss + r1->ru_isrss + r1->ru_idrss) -
 176                          (r0->ru_ixrss + r0->ru_idrss + r0->ru_isrss)) / t));
 177                 break;
 178             case 'M':           /* max. Resident Set Size */
 179                 (void)fprintf(fp, "%ld", r1->ru_maxrss / 2L);
 180                 break;
 181             case 'O':           /* FS blocks out */
 182                 (void)fprintf(fp, "%ld", r1->ru_oublock - r0->ru_oublock);
 183                 break;
 184             case 'P':           /* percent time spent running */
 185                 /* check if it did not run at all */
 186                 if (ms == 0) {
 187                         (void)fputs("0.0%", fp);
 188                 } else {
 189                         char pb[32];
 190                         (void)fputs(strpct(pb, sizeof(pb),
 191                             (uintmax_t)t, (uintmax_t)ms, 1), fp);
 192                         (void)fputc('%', fp);
 193                 }
 194                 break;
 195             case 'R':           /* page reclaims */
 196                 (void)fprintf(fp, "%ld", r1->ru_minflt - r0->ru_minflt);
 197                 break;
 198             case 'S':           /* system CPU time used */
 199                 pdeltat(fp, &r1->ru_stime, &r0->ru_stime);
 200                 break;
 201             case 'U':           /* user CPU time used */
 202                 pdeltat(fp, &r1->ru_utime, &r0->ru_utime);
 203                 break;
 204             case 'W':           /* number of swaps */
 205                 i = r1->ru_nswap - r0->ru_nswap;
 206                 (void)fprintf(fp, "%ld", i);
 207                 break;
 208             case 'X':           /* (average) shared text size */
 209                 (void)fprintf(fp, "%ld", t == 0 ? 0L :
 210                                (long)((r1->ru_ixrss - r0->ru_ixrss) / t));
 211                 break;
 212             case 'c':           /* num. involuntary context switches */
 213                 (void)fprintf(fp, "%ld", r1->ru_nivcsw - r0->ru_nivcsw);
 214                 break;
 215             case 'k':           /* number of signals received */
 216                 (void)fprintf(fp, "%ld", r1->ru_nsignals-r0->ru_nsignals);
 217                 break;
 218             case 'r':           /* socket messages received */
 219                 (void)fprintf(fp, "%ld", r1->ru_msgrcv - r0->ru_msgrcv);
 220                 break;
 221             case 's':           /* socket messages sent */
 222                 (void)fprintf(fp, "%ld", r1->ru_msgsnd - r0->ru_msgsnd);
 223                 break;
 224             case 'w':           /* num. voluntary context switches (waits) */
 225                 (void)fprintf(fp, "%ld", r1->ru_nvcsw - r0->ru_nvcsw);
 226                 break;
 227             }
 228     (void)fputc('\n', fp);
 229 }
 230
 231 static void
 232 pdeltat(FILE *fp, struct timeval *t1, struct timeval *t0)
 233 {
 234     struct timeval td;
 235
 236     timersub(t1, t0, &td);
 237     (void)fprintf(fp, "%ld.%01ld", (long)td.tv_sec,
 238         (long)(td.tv_usec / 100000));
 239 }
 240
 241 #define  P2DIG(fp, i) (void)fprintf(fp, "%ld%ld", (i) / 10, (i) % 10)
 242
 243 #ifndef NOT_CSH
 244 void
 245 psecs(long l)
 246 {
 247     long i;
 248
 249     i = l / 3600;
 250     if (i) {
 251         (void)fprintf(cshout, "%ld:", i);
 252         i = l % 3600;
 253         P2DIG(cshout, i / 60);
 254         goto minsec;
 255     }
 256     i = l;
 257     (void)fprintf(cshout, "%ld", i / 60);
 258 minsec:
 259     i %= 60;
 260     (void)fputc(':', cshout);
 261     P2DIG(cshout, i);
 262 }
 263 #endif
 264
 265 static void
 266 pcsecs(FILE *fp, long l)        /* PWP: print mm:ss.dd, l is in sec*100 */
 267 {
 268     long i;
 269
 270     i = l / 360000;
 271     if (i) {
 272         (void)fprintf(fp, "%ld:", i);
 273         i = (l % 360000) / 100;
 274         P2DIG(fp, i / 60);
 275         goto minsec;
 276     }
 277     i = l / 100;
 278     (void)fprintf(fp, "%ld", i / 60);
 279 minsec:
 280     i %= 60;
 281     (void)fputc(':', fp);
 282     P2DIG(fp, i);
 283     (void)fputc('.', fp);
 284     P2DIG(fp, (l % 100));
 285 }