[821] | 1 | /* vi: set sw=4 ts=4: */
|
---|
[2725] | 2 | /* 'time' utility to display resource usage of processes.
|
---|
[821] | 3 | Copyright (C) 1990, 91, 92, 93, 96 Free Software Foundation, Inc.
|
---|
| 4 |
|
---|
[2725] | 5 | Licensed under GPLv2, see file LICENSE in this source tree.
|
---|
[821] | 6 | */
|
---|
| 7 | /* Originally written by David Keppel <pardo@cs.washington.edu>.
|
---|
| 8 | Heavily modified by David MacKenzie <djm@gnu.ai.mit.edu>.
|
---|
| 9 | Heavily modified for busybox by Erik Andersen <andersen@codepoet.org>
|
---|
| 10 | */
|
---|
| 11 |
|
---|
[1765] | 12 | #include "libbb.h"
|
---|
[821] | 13 |
|
---|
| 14 | /* Information on the resources used by a child process. */
|
---|
| 15 | typedef struct {
|
---|
| 16 | int waitstatus;
|
---|
| 17 | struct rusage ru;
|
---|
[1765] | 18 | unsigned elapsed_ms; /* Wallclock time of process. */
|
---|
[821] | 19 | } resource_t;
|
---|
| 20 |
|
---|
| 21 | /* msec = milliseconds = 1/1,000 (1*10e-3) second.
|
---|
| 22 | usec = microseconds = 1/1,000,000 (1*10e-6) second. */
|
---|
| 23 |
|
---|
| 24 | #define UL unsigned long
|
---|
| 25 |
|
---|
[1765] | 26 | static const char default_format[] ALIGN1 = "real\t%E\nuser\t%u\nsys\t%T";
|
---|
[821] | 27 |
|
---|
| 28 | /* The output format for the -p option .*/
|
---|
[1765] | 29 | static const char posix_format[] ALIGN1 = "real %e\nuser %U\nsys %S";
|
---|
[821] | 30 |
|
---|
| 31 | /* Format string for printing all statistics verbosely.
|
---|
| 32 | Keep this output to 24 lines so users on terminals can see it all.*/
|
---|
[1765] | 33 | static const char long_format[] ALIGN1 =
|
---|
[821] | 34 | "\tCommand being timed: \"%C\"\n"
|
---|
| 35 | "\tUser time (seconds): %U\n"
|
---|
| 36 | "\tSystem time (seconds): %S\n"
|
---|
| 37 | "\tPercent of CPU this job got: %P\n"
|
---|
| 38 | "\tElapsed (wall clock) time (h:mm:ss or m:ss): %E\n"
|
---|
| 39 | "\tAverage shared text size (kbytes): %X\n"
|
---|
| 40 | "\tAverage unshared data size (kbytes): %D\n"
|
---|
| 41 | "\tAverage stack size (kbytes): %p\n"
|
---|
| 42 | "\tAverage total size (kbytes): %K\n"
|
---|
| 43 | "\tMaximum resident set size (kbytes): %M\n"
|
---|
| 44 | "\tAverage resident set size (kbytes): %t\n"
|
---|
| 45 | "\tMajor (requiring I/O) page faults: %F\n"
|
---|
| 46 | "\tMinor (reclaiming a frame) page faults: %R\n"
|
---|
| 47 | "\tVoluntary context switches: %w\n"
|
---|
| 48 | "\tInvoluntary context switches: %c\n"
|
---|
| 49 | "\tSwaps: %W\n"
|
---|
| 50 | "\tFile system inputs: %I\n"
|
---|
| 51 | "\tFile system outputs: %O\n"
|
---|
| 52 | "\tSocket messages sent: %s\n"
|
---|
| 53 | "\tSocket messages received: %r\n"
|
---|
| 54 | "\tSignals delivered: %k\n"
|
---|
[1765] | 55 | "\tPage size (bytes): %Z\n"
|
---|
| 56 | "\tExit status: %x";
|
---|
[821] | 57 |
|
---|
[1765] | 58 | /* Wait for and fill in data on child process PID.
|
---|
| 59 | Return 0 on error, 1 if ok. */
|
---|
[821] | 60 | /* pid_t is short on BSDI, so don't try to promote it. */
|
---|
[2725] | 61 | static void resuse_end(pid_t pid, resource_t *resp)
|
---|
[821] | 62 | {
|
---|
| 63 | pid_t caught;
|
---|
| 64 |
|
---|
| 65 | /* Ignore signals, but don't ignore the children. When wait3
|
---|
| 66 | returns the child process, set the time the command finished. */
|
---|
[2725] | 67 | while ((caught = wait3(&resp->waitstatus, 0, &resp->ru)) != pid) {
|
---|
| 68 | if (caught == -1 && errno != EINTR) {
|
---|
| 69 | bb_perror_msg("wait");
|
---|
| 70 | return;
|
---|
| 71 | }
|
---|
[821] | 72 | }
|
---|
[2725] | 73 | resp->elapsed_ms = monotonic_ms() - resp->elapsed_ms;
|
---|
[821] | 74 | }
|
---|
| 75 |
|
---|
[2725] | 76 | static void printargv(char *const *argv)
|
---|
[821] | 77 | {
|
---|
[2725] | 78 | const char *fmt = " %s" + 1;
|
---|
| 79 | do {
|
---|
| 80 | printf(fmt, *argv);
|
---|
| 81 | fmt = " %s";
|
---|
| 82 | } while (*++argv);
|
---|
[821] | 83 | }
|
---|
| 84 |
|
---|
| 85 | /* Return the number of kilobytes corresponding to a number of pages PAGES.
|
---|
| 86 | (Actually, we use it to convert pages*ticks into kilobytes*ticks.)
|
---|
| 87 |
|
---|
| 88 | Try to do arithmetic so that the risk of overflow errors is minimized.
|
---|
| 89 | This is funky since the pagesize could be less than 1K.
|
---|
| 90 | Note: Some machines express getrusage statistics in terms of K,
|
---|
| 91 | others in terms of pages. */
|
---|
[2725] | 92 | static unsigned long ptok(const unsigned pagesize, const unsigned long pages)
|
---|
[821] | 93 | {
|
---|
| 94 | unsigned long tmp;
|
---|
| 95 |
|
---|
| 96 | /* Conversion. */
|
---|
[2725] | 97 | if (pages > (LONG_MAX / pagesize)) { /* Could overflow. */
|
---|
| 98 | tmp = pages / 1024; /* Smaller first, */
|
---|
| 99 | return tmp * pagesize; /* then larger. */
|
---|
[821] | 100 | }
|
---|
[1765] | 101 | /* Could underflow. */
|
---|
[2725] | 102 | tmp = pages * pagesize; /* Larger first, */
|
---|
| 103 | return tmp / 1024; /* then smaller. */
|
---|
[821] | 104 | }
|
---|
| 105 |
|
---|
| 106 | /* summarize: Report on the system use of a command.
|
---|
| 107 |
|
---|
[1765] | 108 | Print the FMT argument except that `%' sequences
|
---|
[821] | 109 | have special meaning, and `\n' and `\t' are translated into
|
---|
| 110 | newline and tab, respectively, and `\\' is translated into `\'.
|
---|
| 111 |
|
---|
| 112 | The character following a `%' can be:
|
---|
| 113 | (* means the tcsh time builtin also recognizes it)
|
---|
| 114 | % == a literal `%'
|
---|
| 115 | C == command name and arguments
|
---|
| 116 | * D == average unshared data size in K (ru_idrss+ru_isrss)
|
---|
| 117 | * E == elapsed real (wall clock) time in [hour:]min:sec
|
---|
| 118 | * F == major page faults (required physical I/O) (ru_majflt)
|
---|
| 119 | * I == file system inputs (ru_inblock)
|
---|
| 120 | * K == average total mem usage (ru_idrss+ru_isrss+ru_ixrss)
|
---|
| 121 | * M == maximum resident set size in K (ru_maxrss)
|
---|
| 122 | * O == file system outputs (ru_oublock)
|
---|
| 123 | * P == percent of CPU this job got (total cpu time / elapsed time)
|
---|
| 124 | * R == minor page faults (reclaims; no physical I/O involved) (ru_minflt)
|
---|
| 125 | * S == system (kernel) time (seconds) (ru_stime)
|
---|
| 126 | * T == system time in [hour:]min:sec
|
---|
| 127 | * U == user time (seconds) (ru_utime)
|
---|
| 128 | * u == user time in [hour:]min:sec
|
---|
| 129 | * W == times swapped out (ru_nswap)
|
---|
| 130 | * X == average amount of shared text in K (ru_ixrss)
|
---|
| 131 | Z == page size
|
---|
| 132 | * c == involuntary context switches (ru_nivcsw)
|
---|
| 133 | e == elapsed real time in seconds
|
---|
| 134 | * k == signals delivered (ru_nsignals)
|
---|
| 135 | p == average unshared stack size in K (ru_isrss)
|
---|
| 136 | * r == socket messages received (ru_msgrcv)
|
---|
| 137 | * s == socket messages sent (ru_msgsnd)
|
---|
| 138 | t == average resident set size in K (ru_idrss)
|
---|
| 139 | * w == voluntary context switches (ru_nvcsw)
|
---|
| 140 | x == exit status of command
|
---|
| 141 |
|
---|
| 142 | Various memory usages are found by converting from page-seconds
|
---|
| 143 | to kbytes by multiplying by the page size, dividing by 1024,
|
---|
| 144 | and dividing by elapsed real time.
|
---|
| 145 |
|
---|
| 146 | FMT is the format string, interpreted as described above.
|
---|
| 147 | COMMAND is the command and args that are being summarized.
|
---|
| 148 | RESP is resource information on the command. */
|
---|
| 149 |
|
---|
[1765] | 150 | #ifndef TICKS_PER_SEC
|
---|
| 151 | #define TICKS_PER_SEC 100
|
---|
| 152 | #endif
|
---|
| 153 |
|
---|
[2725] | 154 | static void summarize(const char *fmt, char **command, resource_t *resp)
|
---|
[821] | 155 | {
|
---|
[1765] | 156 | unsigned vv_ms; /* Elapsed virtual (CPU) milliseconds */
|
---|
| 157 | unsigned cpu_ticks; /* Same, in "CPU ticks" */
|
---|
[2725] | 158 | unsigned pagesize = getpagesize();
|
---|
[821] | 159 |
|
---|
[2725] | 160 | /* Impossible: we do not use WUNTRACED flag in wait()...
|
---|
[821] | 161 | if (WIFSTOPPED(resp->waitstatus))
|
---|
[1765] | 162 | printf("Command stopped by signal %u\n",
|
---|
[821] | 163 | WSTOPSIG(resp->waitstatus));
|
---|
[2725] | 164 | else */
|
---|
| 165 | if (WIFSIGNALED(resp->waitstatus))
|
---|
[1765] | 166 | printf("Command terminated by signal %u\n",
|
---|
[821] | 167 | WTERMSIG(resp->waitstatus));
|
---|
| 168 | else if (WIFEXITED(resp->waitstatus) && WEXITSTATUS(resp->waitstatus))
|
---|
[1765] | 169 | printf("Command exited with non-zero status %u\n",
|
---|
[821] | 170 | WEXITSTATUS(resp->waitstatus));
|
---|
| 171 |
|
---|
[1765] | 172 | vv_ms = (resp->ru.ru_utime.tv_sec + resp->ru.ru_stime.tv_sec) * 1000
|
---|
| 173 | + (resp->ru.ru_utime.tv_usec + resp->ru.ru_stime.tv_usec) / 1000;
|
---|
[821] | 174 |
|
---|
[1765] | 175 | #if (1000 / TICKS_PER_SEC) * TICKS_PER_SEC == 1000
|
---|
[2725] | 176 | /* 1000 is exactly divisible by TICKS_PER_SEC (typical) */
|
---|
[1765] | 177 | cpu_ticks = vv_ms / (1000 / TICKS_PER_SEC);
|
---|
| 178 | #else
|
---|
| 179 | cpu_ticks = vv_ms * (unsigned long long)TICKS_PER_SEC / 1000;
|
---|
| 180 | #endif
|
---|
| 181 | if (!cpu_ticks) cpu_ticks = 1; /* we divide by it, must be nonzero */
|
---|
[821] | 182 |
|
---|
| 183 | while (*fmt) {
|
---|
[1765] | 184 | /* Handle leading literal part */
|
---|
| 185 | int n = strcspn(fmt, "%\\");
|
---|
| 186 | if (n) {
|
---|
| 187 | printf("%.*s", n, fmt);
|
---|
| 188 | fmt += n;
|
---|
| 189 | continue;
|
---|
| 190 | }
|
---|
| 191 |
|
---|
[821] | 192 | switch (*fmt) {
|
---|
[1765] | 193 | #ifdef NOT_NEEDED
|
---|
| 194 | /* Handle literal char */
|
---|
| 195 | /* Usually we optimize for size, but there is a limit
|
---|
| 196 | * for everything. With this we do a lot of 1-byte writes */
|
---|
| 197 | default:
|
---|
[2725] | 198 | bb_putchar(*fmt);
|
---|
[1765] | 199 | break;
|
---|
| 200 | #endif
|
---|
| 201 |
|
---|
[821] | 202 | case '%':
|
---|
| 203 | switch (*++fmt) {
|
---|
[1765] | 204 | #ifdef NOT_NEEDED_YET
|
---|
| 205 | /* Our format strings do not have these */
|
---|
| 206 | /* and we do not take format str from user */
|
---|
| 207 | default:
|
---|
[2725] | 208 | bb_putchar('%');
|
---|
[1765] | 209 | /*FALLTHROUGH*/
|
---|
| 210 | case '%':
|
---|
| 211 | if (!*fmt) goto ret;
|
---|
[2725] | 212 | bb_putchar(*fmt);
|
---|
[821] | 213 | break;
|
---|
[1765] | 214 | #endif
|
---|
[821] | 215 | case 'C': /* The command that got timed. */
|
---|
[2725] | 216 | printargv(command);
|
---|
[821] | 217 | break;
|
---|
| 218 | case 'D': /* Average unshared data size. */
|
---|
[1765] | 219 | printf("%lu",
|
---|
[2725] | 220 | (ptok(pagesize, (UL) resp->ru.ru_idrss) +
|
---|
| 221 | ptok(pagesize, (UL) resp->ru.ru_isrss)) / cpu_ticks);
|
---|
[821] | 222 | break;
|
---|
[1765] | 223 | case 'E': { /* Elapsed real (wall clock) time. */
|
---|
| 224 | unsigned seconds = resp->elapsed_ms / 1000;
|
---|
| 225 | if (seconds >= 3600) /* One hour -> h:m:s. */
|
---|
| 226 | printf("%uh %um %02us",
|
---|
| 227 | seconds / 3600,
|
---|
| 228 | (seconds % 3600) / 60,
|
---|
| 229 | seconds % 60);
|
---|
[821] | 230 | else
|
---|
[1765] | 231 | printf("%um %u.%02us", /* -> m:s. */
|
---|
| 232 | seconds / 60,
|
---|
| 233 | seconds % 60,
|
---|
| 234 | (unsigned)(resp->elapsed_ms / 10) % 100);
|
---|
[821] | 235 | break;
|
---|
[1765] | 236 | }
|
---|
[821] | 237 | case 'F': /* Major page faults. */
|
---|
[1765] | 238 | printf("%lu", resp->ru.ru_majflt);
|
---|
[821] | 239 | break;
|
---|
| 240 | case 'I': /* Inputs. */
|
---|
[1765] | 241 | printf("%lu", resp->ru.ru_inblock);
|
---|
[821] | 242 | break;
|
---|
| 243 | case 'K': /* Average mem usage == data+stack+text. */
|
---|
[1765] | 244 | printf("%lu",
|
---|
[2725] | 245 | (ptok(pagesize, (UL) resp->ru.ru_idrss) +
|
---|
| 246 | ptok(pagesize, (UL) resp->ru.ru_isrss) +
|
---|
| 247 | ptok(pagesize, (UL) resp->ru.ru_ixrss)) / cpu_ticks);
|
---|
[821] | 248 | break;
|
---|
| 249 | case 'M': /* Maximum resident set size. */
|
---|
[2725] | 250 | printf("%lu", ptok(pagesize, (UL) resp->ru.ru_maxrss));
|
---|
[821] | 251 | break;
|
---|
| 252 | case 'O': /* Outputs. */
|
---|
[1765] | 253 | printf("%lu", resp->ru.ru_oublock);
|
---|
[821] | 254 | break;
|
---|
| 255 | case 'P': /* Percent of CPU this job got. */
|
---|
| 256 | /* % cpu is (total cpu time)/(elapsed time). */
|
---|
[1765] | 257 | if (resp->elapsed_ms > 0)
|
---|
| 258 | printf("%u%%", (unsigned)(vv_ms * 100 / resp->elapsed_ms));
|
---|
[821] | 259 | else
|
---|
[1765] | 260 | printf("?%%");
|
---|
[821] | 261 | break;
|
---|
| 262 | case 'R': /* Minor page faults (reclaims). */
|
---|
[1765] | 263 | printf("%lu", resp->ru.ru_minflt);
|
---|
[821] | 264 | break;
|
---|
| 265 | case 'S': /* System time. */
|
---|
[1765] | 266 | printf("%u.%02u",
|
---|
| 267 | (unsigned)resp->ru.ru_stime.tv_sec,
|
---|
| 268 | (unsigned)(resp->ru.ru_stime.tv_usec / 10000));
|
---|
[821] | 269 | break;
|
---|
| 270 | case 'T': /* System time. */
|
---|
| 271 | if (resp->ru.ru_stime.tv_sec >= 3600) /* One hour -> h:m:s. */
|
---|
[1765] | 272 | printf("%uh %um %02us",
|
---|
| 273 | (unsigned)(resp->ru.ru_stime.tv_sec / 3600),
|
---|
| 274 | (unsigned)(resp->ru.ru_stime.tv_sec % 3600) / 60,
|
---|
| 275 | (unsigned)(resp->ru.ru_stime.tv_sec % 60));
|
---|
[821] | 276 | else
|
---|
[1765] | 277 | printf("%um %u.%02us", /* -> m:s. */
|
---|
| 278 | (unsigned)(resp->ru.ru_stime.tv_sec / 60),
|
---|
| 279 | (unsigned)(resp->ru.ru_stime.tv_sec % 60),
|
---|
| 280 | (unsigned)(resp->ru.ru_stime.tv_usec / 10000));
|
---|
[821] | 281 | break;
|
---|
| 282 | case 'U': /* User time. */
|
---|
[1765] | 283 | printf("%u.%02u",
|
---|
| 284 | (unsigned)resp->ru.ru_utime.tv_sec,
|
---|
| 285 | (unsigned)(resp->ru.ru_utime.tv_usec / 10000));
|
---|
[821] | 286 | break;
|
---|
| 287 | case 'u': /* User time. */
|
---|
| 288 | if (resp->ru.ru_utime.tv_sec >= 3600) /* One hour -> h:m:s. */
|
---|
[1765] | 289 | printf("%uh %um %02us",
|
---|
| 290 | (unsigned)(resp->ru.ru_utime.tv_sec / 3600),
|
---|
| 291 | (unsigned)(resp->ru.ru_utime.tv_sec % 3600) / 60,
|
---|
| 292 | (unsigned)(resp->ru.ru_utime.tv_sec % 60));
|
---|
[821] | 293 | else
|
---|
[1765] | 294 | printf("%um %u.%02us", /* -> m:s. */
|
---|
| 295 | (unsigned)(resp->ru.ru_utime.tv_sec / 60),
|
---|
| 296 | (unsigned)(resp->ru.ru_utime.tv_sec % 60),
|
---|
| 297 | (unsigned)(resp->ru.ru_utime.tv_usec / 10000));
|
---|
[821] | 298 | break;
|
---|
| 299 | case 'W': /* Times swapped out. */
|
---|
[1765] | 300 | printf("%lu", resp->ru.ru_nswap);
|
---|
[821] | 301 | break;
|
---|
| 302 | case 'X': /* Average shared text size. */
|
---|
[2725] | 303 | printf("%lu", ptok(pagesize, (UL) resp->ru.ru_ixrss) / cpu_ticks);
|
---|
[821] | 304 | break;
|
---|
| 305 | case 'Z': /* Page size. */
|
---|
[2725] | 306 | printf("%u", pagesize);
|
---|
[821] | 307 | break;
|
---|
| 308 | case 'c': /* Involuntary context switches. */
|
---|
[1765] | 309 | printf("%lu", resp->ru.ru_nivcsw);
|
---|
[821] | 310 | break;
|
---|
| 311 | case 'e': /* Elapsed real time in seconds. */
|
---|
[1765] | 312 | printf("%u.%02u",
|
---|
| 313 | (unsigned)resp->elapsed_ms / 1000,
|
---|
| 314 | (unsigned)(resp->elapsed_ms / 10) % 100);
|
---|
[821] | 315 | break;
|
---|
| 316 | case 'k': /* Signals delivered. */
|
---|
[1765] | 317 | printf("%lu", resp->ru.ru_nsignals);
|
---|
[821] | 318 | break;
|
---|
| 319 | case 'p': /* Average stack segment. */
|
---|
[2725] | 320 | printf("%lu", ptok(pagesize, (UL) resp->ru.ru_isrss) / cpu_ticks);
|
---|
[821] | 321 | break;
|
---|
| 322 | case 'r': /* Incoming socket messages received. */
|
---|
[1765] | 323 | printf("%lu", resp->ru.ru_msgrcv);
|
---|
[821] | 324 | break;
|
---|
| 325 | case 's': /* Outgoing socket messages sent. */
|
---|
[1765] | 326 | printf("%lu", resp->ru.ru_msgsnd);
|
---|
[821] | 327 | break;
|
---|
| 328 | case 't': /* Average resident set size. */
|
---|
[2725] | 329 | printf("%lu", ptok(pagesize, (UL) resp->ru.ru_idrss) / cpu_ticks);
|
---|
[821] | 330 | break;
|
---|
| 331 | case 'w': /* Voluntary context switches. */
|
---|
[1765] | 332 | printf("%lu", resp->ru.ru_nvcsw);
|
---|
[821] | 333 | break;
|
---|
| 334 | case 'x': /* Exit status. */
|
---|
[1765] | 335 | printf("%u", WEXITSTATUS(resp->waitstatus));
|
---|
[821] | 336 | break;
|
---|
| 337 | }
|
---|
| 338 | break;
|
---|
| 339 |
|
---|
[1765] | 340 | #ifdef NOT_NEEDED_YET
|
---|
[821] | 341 | case '\\': /* Format escape. */
|
---|
| 342 | switch (*++fmt) {
|
---|
[1765] | 343 | default:
|
---|
[2725] | 344 | bb_putchar('\\');
|
---|
[1765] | 345 | /*FALLTHROUGH*/
|
---|
| 346 | case '\\':
|
---|
| 347 | if (!*fmt) goto ret;
|
---|
[2725] | 348 | bb_putchar(*fmt);
|
---|
[1765] | 349 | break;
|
---|
[821] | 350 | case 't':
|
---|
[2725] | 351 | bb_putchar('\t');
|
---|
[821] | 352 | break;
|
---|
| 353 | case 'n':
|
---|
[2725] | 354 | bb_putchar('\n');
|
---|
[821] | 355 | break;
|
---|
| 356 | }
|
---|
| 357 | break;
|
---|
[1765] | 358 | #endif
|
---|
[821] | 359 | }
|
---|
[1765] | 360 | ++fmt;
|
---|
[821] | 361 | }
|
---|
[1765] | 362 | /* ret: */
|
---|
[2725] | 363 | bb_putchar('\n');
|
---|
[821] | 364 | }
|
---|
| 365 |
|
---|
| 366 | /* Run command CMD and return statistics on it.
|
---|
| 367 | Put the statistics in *RESP. */
|
---|
[2725] | 368 | static void run_command(char *const *cmd, resource_t *resp)
|
---|
[821] | 369 | {
|
---|
[2725] | 370 | pid_t pid;
|
---|
| 371 | void (*interrupt_signal)(int);
|
---|
| 372 | void (*quit_signal)(int);
|
---|
[821] | 373 |
|
---|
[2725] | 374 | resp->elapsed_ms = monotonic_ms();
|
---|
| 375 | pid = xvfork();
|
---|
| 376 | if (pid == 0) {
|
---|
| 377 | /* Child */
|
---|
| 378 | BB_EXECVP_or_die((char**)cmd);
|
---|
[821] | 379 | }
|
---|
| 380 |
|
---|
| 381 | /* Have signals kill the child but not self (if possible). */
|
---|
[2725] | 382 | //TODO: just block all sigs? and reenable them in the very end in main?
|
---|
[821] | 383 | interrupt_signal = signal(SIGINT, SIG_IGN);
|
---|
| 384 | quit_signal = signal(SIGQUIT, SIG_IGN);
|
---|
| 385 |
|
---|
[2725] | 386 | resuse_end(pid, resp);
|
---|
[821] | 387 |
|
---|
| 388 | /* Re-enable signals. */
|
---|
| 389 | signal(SIGINT, interrupt_signal);
|
---|
| 390 | signal(SIGQUIT, quit_signal);
|
---|
| 391 | }
|
---|
| 392 |
|
---|
[2725] | 393 | int time_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
| 394 | int time_main(int argc UNUSED_PARAM, char **argv)
|
---|
[821] | 395 | {
|
---|
| 396 | resource_t res;
|
---|
| 397 | const char *output_format = default_format;
|
---|
[2725] | 398 | int opt;
|
---|
[821] | 399 |
|
---|
[2725] | 400 | opt_complementary = "-1"; /* at least one arg */
|
---|
| 401 | /* "+": stop on first non-option */
|
---|
| 402 | opt = getopt32(argv, "+vp");
|
---|
| 403 | argv += optind;
|
---|
| 404 | if (opt & 1)
|
---|
| 405 | output_format = long_format;
|
---|
| 406 | if (opt & 2)
|
---|
| 407 | output_format = posix_format;
|
---|
[821] | 408 |
|
---|
| 409 | run_command(argv, &res);
|
---|
| 410 |
|
---|
[1765] | 411 | /* Cheat. printf's are shorter :) */
|
---|
[2725] | 412 | xdup2(STDERR_FILENO, STDOUT_FILENO);
|
---|
[1765] | 413 | summarize(output_format, argv, &res);
|
---|
| 414 |
|
---|
[821] | 415 | if (WIFSTOPPED(res.waitstatus))
|
---|
[1765] | 416 | return WSTOPSIG(res.waitstatus);
|
---|
| 417 | if (WIFSIGNALED(res.waitstatus))
|
---|
| 418 | return WTERMSIG(res.waitstatus);
|
---|
| 419 | if (WIFEXITED(res.waitstatus))
|
---|
| 420 | return WEXITSTATUS(res.waitstatus);
|
---|
[2725] | 421 | fflush_stdout_and_exit(EXIT_SUCCESS);
|
---|
[821] | 422 | }
|
---|