process synchronization with signals deadlock case - c

Question

I need to synchronize parent and child process to work in order in endless loop but I am getting deadlock after a while.
I am not allowed to use sleep, wait and I must implement the synchronization with signals. After a search I found a similar question which is used pause method, in the answers it is recommended to use sigsuspend rather than pause. So I am not sure if there is problem with my implementation or I need to use another way to avoid deadlock
Heres my code
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
void catcher( int sig ) {
printf( "inside catcher() function\n" );
}
void timestamp( char *str ) {
time_t t;
time( &t );
printf( "%s the time is %s\n", str, ctime(&t) );
}
int main( int argc, char *argv[] ) {
struct sigaction sigact;
sigset_t block_set1,block_set2;
sigfillset( &block_set1 );
sigfillset( &block_set2 );
sigdelset( &block_set1, SIGUSR1 );
sigdelset( &block_set2, SIGUSR2 );
sigemptyset( &sigact.sa_mask );
sigact.sa_flags = 0;
sigact.sa_handler = catcher;
sigaction( SIGUSR1, &sigact, NULL );
sigaction( SIGUSR2, &sigact, NULL );
pid_t child_id;
child_id = fork ();
if (child_id == 0){
while(1){
printf("child send signal\n");
kill (getppid (), SIGUSR1);
printf("child wait signal\n");
sigsuspend( &block_set2 );
printf("child is going to die\n");
}
}else{
while(1){
timestamp( "before sigsuspend()" );
sigsuspend( &block_set1 );
timestamp( "after sigsuspend()" );
kill (child_id, SIGUSR2);
printf("parent is going to die\n");
}
}
return( 0 );
}

Answer 1

This program has an issue, Consider a scenario where child/parent sends a signal to parent/child even before they suspend their execution using sigsuspend(). In this case handler will be executed and later no one will be
their to interrupt sigsupend() which may arise to infinite suspend state.
Quoting man page
int sigsuspend(const sigset_t *mask);
sigsuspend() temporarily replaces the signal mask of the calling
process with the mask given by mask and then suspends the process
until delivery of a signal whose action is to invoke a signal handler
or to terminate a process.
I would suggest to use sigwaitinfo() instead,
int sigwaitinfo(const sigset_t *set, siginfo_t *info);
sigwaitinfo() suspends execution of the calling thread until one of
the signals in set is pending (If one of the signals in set is already
pending for the calling thread, sigwaitinfo() will return
immediately.)
Please find the example program for same.
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
void timestamp( char *str ) {
time_t t;
time( &t );
printf( "%s the time is %s\n", str, ctime(&t) );
}
int main( int argc, char *argv[] ) {
sigset_t parent_set, child_set;
sigset_t set;
siginfo_t info;
/*Mask SIGUSR2 and SIGUSR1 signal, you can choose this mask
* according to your requirement*/
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
sigaddset(&set, SIGUSR2);
sigprocmask(SIG_SETMASK, &set, NULL);
sigemptyset(&child_set);
sigaddset(&child_set, SIGUSR2);
sigemptyset(&parent_set);
sigaddset(&parent_set, SIGUSR1);
pid_t child_id;
child_id = fork ();
if (child_id == 0){
while(1){
printf("child send signal\n");
kill (getppid (), SIGUSR1);
printf("child wait signal\n");
/* Child will suspend its execution if parent did not notify it
* using signal(SIGUSR2), if parent has already notified sigwaitinfo()
* will return immediately
**/
sigwaitinfo(&child_set, &info );
printf("child is going to die\n");
}
}else{
while(1){
timestamp( "before sigwaitinfo()" );
/* Parent will suspend its execution if child did not notify it
* using signal(SIGUSR1), if child has already notified sigwaitinfo()
* will return immediately
**/
sigwaitinfo(&parent_set, &info );
timestamp( "after sigwaitinfo()" );
kill (child_id, SIGUSR2);
printf("parent is going to die\n");
}
}
}
I hope this will help you.

Answer 2

The problem, as #monc noted, is that one process signals the other when the other process isn't ready.
So, the signal is delivered (i.e., the sigaction() handler is invoked) before the call to sigsuspend(), and thus the delivery cannot interrupt the sigsuspend(). Something like this happens:
while(1){
printf("child send signal\n");
kill (getppid (), SIGUSR1);
// SIGUSR2 delivered here
printf("child wait signal\n"); // or here
// or here
sigsuspend( &block_set2 ); // wait forever...
...
}
The solution is to block (mask) SIGUSR1 in the parent and SIGUSR2 in the child from the very start. Blocking the signals will forestall delivery, keeping them pending until sigsuspend() atomically swaps out the signal mask to allow delivery (and interruption). To be safe, the signals should be blocked before you call fork(), and the child can inherit the signal mask from the parent:
sigemptyset(&ss);
sigaddset(&ss, SIGUSR1);
sigaddset(&ss, SIGUSR2);
sigprocmask(SIG_BLOCK, &ss, NULL);
... fork();
// child
while (1) {
sigset_t wakemask;
sigemptyset(&wakemask);
...
sigsuspend(&wakemask);
}
// similarly for parent ...
Note that in the above the parent and child are each blocking both signals, including the ones they send to each other. That's not necessary — you could unblock right after the fork() — but also not harmful.
Additionally, you could also accept rather than deliver the signals using the sigwait family of functions. In this case you would not need to set a handler with sigaction, but you would still need to block the signals.