Previous: Permission for kill, Up: Generating Signals

#### 24.6.4 Using `kill` for Communication

Here is a longer example showing how signals can be used for interprocess communication. This is what the `SIGUSR1` and `SIGUSR2` signals are provided for. Since these signals are fatal by default, the process that is supposed to receive them must trap them through `signal` or `sigaction`.

In this example, a parent process forks a child process and then waits for the child to complete its initialization. The child process tells the parent when it is ready by sending it a `SIGUSR1` signal, using the `kill` function.

         #include <signal.h>
         #include <stdio.h>
         #include <sys/types.h>
         #include <unistd.h>

         /* When a SIGUSR1 signal arrives, set this variable. */
         volatile sig_atomic_t usr_interrupt = 0;

         void
         synch_signal (int sig)
         {
           usr_interrupt = 1;
         }

         /* The child process executes this function. */
         void
         child_function (void)
         {
           /* Perform initialization. */
           printf ("I'm here!!!  My pid is %d.\n", (int) getpid ());

           /* Let parent know you're done. */
           kill (getppid (), SIGUSR1);

           /* Continue with execution. */
           puts ("Bye, now....");
           exit (0);
         }

         int
         main (void)
         {
           struct sigaction usr_action;
           sigset_t block_mask;
           pid_t child_id;

           /* Establish the signal handler. */
           sigfillset (&block_mask);
           usr_action.sa_handler = synch_signal;
           usr_action.sa_mask = block_mask;
           usr_action.sa_flags = 0;
           sigaction (SIGUSR1, &usr_action, NULL);

           /* Create the child process. */
           child_id = fork ();
           if (child_id == 0)
             child_function ();          /* Does not return. */

           /* Busy wait for the child to send a signal. */
           while (!usr_interrupt)
             ;

           /* Now continue execution. */
           puts ("That's all, folks!");

           return 0;
         }

This example uses a busy wait, which is bad, because it wastes CPU cycles that other programs could otherwise use. It is better to ask the system to wait until the signal arrives. See the example in Waiting for a Signal.