First Signal Handler Example

Source code can install a signal handler to catch and handle a certain type of signal in a way that's different than the default.

Here's a carefully coded example that illustrates how to implement and install a SIGCHLD handler (over two slides). The premise is that dad takes his five kids out to play. Each of the five children plays for a different length of time. When all five children are tired of playing, the six of them (five kids and their dad) all go home.
Understand that the parent process is modeling dad, and that the child processes are modeling his children. (Code can be found right here).

static const size_t kNumChildren = 5;
static size_t numChildrenDonePlaying = 0;

static void reapChild(int sig) {
  exitIf(waitpid(-1, NULL, 0) == -1, kWaitFailed,
         stderr, "waitpid failed within reapChild sighandler.\n");
  numChildrenDonePlaying++;
  sleep(1); // represents time spent doing other useful work
}

int main(int argc, char *argv[]) {
  printf("Let my five children play while I take a nap.\n");
  exitIf(signal(SIGCHLD, reapChild) == SIG_ERR, kSignalFailed,
         stderr, "Failed to install SIGCHLD handler.\n");
  for (size_t kid = 1; kid <= 5; kid++) {
    pid_t pid = fork();
    exitIf(pid == -1, kForkFailed, stderr, "Child #%zu doesn't want to play.\n", kid);
    if (pid == 0) {
      sleep(3 * kid); // sleep emulates "play" time
      printf("Child #%zu tired... returns to dad.\n", kid);
      return 0;
    }
  }

First Signal Handler Example (Continued)

Here's the second half of the program from the last slide:

Notice the use of the snooze function, which is my own implementation of an uninterruptable sleep:

  while (numChildrenDonePlaying < kNumChildren) {
    printf("At least one child still playing, so dad nods off.\n");
    snooze(5); // implementation in /usr/class/cs110/local/include/sleep-utils.h
    printf("Dad wakes up! ");
  }

  printf("All children accounted for.  Good job, dad!\n");
  return 0;
}

The above code is specifically crafted so each child process exits about 3 seconds apart. reapChild, of course, catches and handles each of the SIGCHLD signals delivered by the kernel as each forked child process exits. reapChild is contrived to take about a second to execute to completion, so each reapChild finishes about two seconds before the next child process exits.
The signal function doesn't allow for state to be shared with the signal handler, so we have no choice but to use globals.
Here's the fairly predictable output of the above program.

myth22> ./five-children 
Let my five children play while I take a nap.
At least one child still playing, so dad nods off.
Child #1 tired... returns to dad.
Child #2 tired... returns to dad.
Dad wakes up! At least one child still playing, so dad nods off.
Child #3 tired... returns to dad.
Child #4 tired... returns to dad.
Dad wakes up! At least one child still playing, so dad nods off.
Child #5 tired... returns to dad.
Dad wakes up! All children accounted for.  Good job, dad!
myth22>