Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




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;
     synch_signal (int sig)
       usr_interrupt = 1;
     /* The child process executes this function. */
     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);
     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.

  Published under the terms of the GNU General Public License Design by Interspire