information available after the `wait` call - c

Question

I wrote a program that verifies that the getrusage () RUSAGE_CHILDREN flag retrieves certain information only about children for whom a wait call was made,
How can I modify the program so that it is more efficient in terms of handling errors? There is also danger of a 2038 bug occurring on this line: printf (" before: user CPU seconds =% ld \ n ", (long) usg.ru_utime.tv_sec);?
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "print_rlimit.h"
int
main (void)
{
switch (fork ()) {
case -1:
perror ("fork()");
return 1;
case 0: { // child
time_t start, now;
alarm (10);
start = time (NULL);
while (1) {
now = time (NULL);
if ((now - start) > 5)
break;
}
_exit (0);
}
default: { // parent
int ret;
struct rusage usg;
pid_t pid;
sleep (2);
ret = getrusage (RUSAGE_CHILDREN, &usg);
if (ret == -1) {
perror ("getrusage()");
return 1;
}
printf ("before: user CPU seconds = %ld\n", (long)usg.ru_utime.tv_sec);
pid = wait (NULL);
if (pid == (pid_t)-1) {
perror ("wait()");
return 1;
}
ret = getrusage (RUSAGE_CHILDREN, &usg);
if (ret == -1) {
perror ("getrusage()");
return 1;
}
printf ("after: user CPU seconds = %ld\n", (long)usg.ru_utime.tv_sec);
break;
}
}
return 0;
}
header:
#ifndef _PRINT_RLIMITS
#define _PRINT_RLIMITS
void print_rlimit (int resource);
#endif

Answer 1

2038 bug
time_t is not specified as a long, so do not cast to long which may only be 32-bit and narrow the time value.
// printf (" before: user CPU seconds =% ld \ n ", (long) usg.ru_utime.tv_sec);
time_t is not certainly even an integer count of seconds. A reasonable alternative is to cast to the widest integer type. This will accommodate an implementation that uses a wider integer type for time_t to handle the 2038 bug.
#include <inttypes.h>
printf (" before: user CPU seconds = %jd\n", (intmax_t) usg.ru_utime.tv_sec);
time_t quanta assumed
Rather than assume time_t is an integer count of seconds, use standard double difftime(time_t time1, time_t time0) which returns a difference in seconds regardless of time_t encoding.
// (now - start) > 5
difftime(now, start) > 5.0
Burning CPU
while (1) { now = time (NULL); ... burns lots of CPU ticks while waiting. A more advanced idea would sleep for some time before trying again.
while (1) {
now = time (NULL);
double diff = difftime(now, start);
if (diff > 5) {
break;
}
diff *= 1000000; // microseconds
usleep(diff/2); // Sleep for half of that
}
A more advanced approach would use other system alarm routines.
Missing error handling
Below is an infinite loop should time() return -1 if the calendar time is not available. To fix, test for -1.
start = time (NULL);
while (1) {
now = time (NULL);
if ((now - start) > 5)
break;
}
Minor: cast needed?
On many implementations pid_t is a signed integer type so the cast is superfluous.
// pid == (pid_t)-1
pid == -1