Wait for child process without using wait()

Just a few minutes ago, I sent an email to Remiz, the author of this book, and received the following response:

Without calling wait() is hard, and not really the main point. What you did -- learning about signals on your own -- is a good sign, showing you will seek out deeper knowledge. Good for you!

Later, you'll be able to use a shared memory segment, and either condition variables or semaphores, to solve this problem.

I can't see why second question would imply that answer is "yes" to the first.

Yes there is plenty of solutions to obtain what asked, but of course I suspect that all are not in the "spirit" of the problem/question where the focus in on fork/wait primitives. The point is always to remember that you can't assume anything after a fork regarding the way processes ran relatively to each other.

To ensure the child process print first you need a kind of synchronization in between both processes, and there is a lot of system primitives that have a semantic of "communication" between processes (for example locks, semaphores, signals, etc). I doubt one of these is to be used her, as they are generally introduced slightly later in such a course.

Any other attempt only that will only rely on time assumption (like using sleep or loops to "slow" down the parent, etc) can lead to failure, means that you will not be able to prove that it will always succeed. Even if testing would probably show you that it seems correct, most of the runs you would try will not have the bad characteristics that lead to failure. Remember that except in realtime OSes, scheduling is almost an approximation of fair concurrency.

NOTE:

As Jonathan Leffler commented, I also suppose that using other wait-like primitives is forbidden (aka wait4, waitpid, etc) -- "spirit" argument.

You can use signals, which basically are being sent from the OS to the process. There are different types of signals. One that I am using here is SIGCHLD, which is a signal sent to the parent when the child exits. Normally by default it just ignores it. With the help of signal handlers you can determine how to handle that signal, or basically what to do when that signal is being sent.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>

volatile int child_finished = 0;

void sigchild_handler(int sig) {
    child_finished = 1;
}

int main(int argc, char *argv[]) {
    int rc = fork(); // rc in short for return code
    // normally when a SIGCHLD is being sent, default is to ignore it
    // SIGCHLD is basically the signal that the child is finished executing
    signal(SIGCHLD, sigchild_handler);
    if (rc < 0) {
        fprintf(stderr, "fork failed\n");
        exit(1); // terminates the program from wherever you are
    } else if (rc == 0) {
        printf("hello\n");
        exit(0);
    } else {
        while (!child_finished) {};
        printf("goodbye\n");
    }
    return 0;
}

I'm using the idea of using signals that was proposed here earlier. A thing to note is that you will have to make the call to fork() after setting up the signal handler to avoid a race condition (otherwise, there is a chance the child terminates first before the parent sets up the signal handler, in which case the signal would be ignored).

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>

volatile int child_finished = 0;

void sigchild_handler(int sig) {
    child_finished = 1;
}

int main(int argc, char *argv[]) {
    // normally when a SIGCHLD is being sent, default is to ignore it
    // SIGCHLD is basically the signal that the child is finished executing
    signal(SIGCHLD, sigchild_handler);
    int rc = fork(); // rc in short for return code
    if (rc < 0) {
        fprintf(stderr, "fork failed\n");
        exit(1); // terminates the program from wherever you are
    } else if (rc == 0) {
        printf("hello\n");
        exit(0);
    } else {
        while (!child_finished) {};
        printf("goodbye\n");
    }
    return 0;
}

You can use the sleep() function to sleep the parent process for some time, like in seconds, sleep(2). This will sleep or act like a wait for a number of seconds that you have passed as an argument in the sleep function.

Here is the code example:

   int main(int arg_counter, char *argv[]) {
    int child_process = fork();
    if(child_process < 0) {
        printf("Could not create child process");
        return 0;
    } else if(child_process == 0) {
        printf("Hello\n");
        return 0;
    } else {
        sleep(1);
        printf("Good Bye\n");
    }
    return 0;
}

Do not forget to include <signal.h> library first. 😊