Thread: signal to process

I have a parent process and many children.
The childrens' pids are stored in an array of ints.
at some point of the program I want to send a signal to all the children from the parent process and then wait until ALL of them send a signal back to the parent.For one child it works but for more there're problems.

Code:

//parent process
int pids[c]; //c is the number of children
for(int i=0;i<c;i++){
   kill(pids[i],REQ); //req is the signal the parent sends
}

this loop doesn't work for many children as they seem never to catch the signal.When I change it to:

Code:

kill(0,REQ); //send signal to every process

they catch the signal from the parent,and they execute their function f:

Code:

void f(int signum){
     cout<<"Signal caught from child!"<<endl;
     kill(getppid(),REQ1); //send a response signal to the parent
     exit(1);
}

but the parent never receives that signal,and I assume is due to the fact that after the parent's command "kill" (where the signal is sent to all of its children) there's the return statement of the main function.So I guess the parent never receives any signal from the children because its already terminated.Is there a way for the parrent to wait until it receives c signal responses and then terminate?

I just figured that the problem must be here:

Code:

waitpid(pids[i],&status,0);

The parent sends the signal to the first child and receives the answer,executes its function which handles the signal and then blocks on waitpid and never goes to the next loop of for-loop

Originally Posted by Salem

Actually, if your signals are being caught and handled, then the process isn't going to die, so there is no need to wait.

You only need waitpid IF the child is going to die.

Thank you very much for your answer.There're just a few things I don't understand,if you could explain to me
First,what is the use of the volatile int?(Never seen that again before)
Secondly,what I want is the parent to send the SIGUSR2 to all of its children and when they receive it to send him back SIGUSR1.When the parent receives that signal from all of his children then it terminates.On the other hand when the children receive SIGUSR2 and send back to the parent the SIGUSR1,they also have to terminate.I'm saying all these again because I want to make sure what the code you suggested does.It's very nice but I cannot fully understand what you're doing..

Also what are the sleeps for?Are they necessary?

Originally Posted by Salem

> First,what is the use of the volatile int?(Never seen that again before)
Consider it an opportunity to learn by reading your C book.

> Also what are the sleeps for?Are they necessary?
Well you could remove them and see what happens.

> Secondly,what I want is the parent to send the SIGUSR2 to all of its children and when they receive it to send him back SIGUSR1.
Like I said previously, there is no issue with this in theory, except for the fact that signals are NOT QUEUED.
1 parent sending N signals to N children (one per child) isn't a problem.
N children sending N signals back to 1 parent is however.

I'd like to see some of your attempts at solving this before just giving you your homework.

I tried it as you suggested and a strange thing occured..
In the child process there's the loop:

Code:

while(!c1){
//do things--I removed sleep()--
}

once the child is alive it runs this loop.In the loop there's a getline that reads from a pipe,so all the other commands of the loop are executed only when the child has something to read from the pipe(communicates with the parent),otherwise the child is blocked and is waiting.When the first child receives the signal from the parent,executes its signal handler function.So the parent does:

Code:

for(int k=0;k<numberOfProcesses;k++){
    cout<<"sending signal to "<<childpid[k]<<endl;
    kill(childpid[k],SIGUSR1);
    cout<<"Signal sent to "<<childpid[k]<<endl;
    while(!p1){
        cout<<"";
	//sleep(1);
     }
     cout<<"finally reached here!"<<endl;
    //rest of the code you suggested
}

the first 2 couts are printed ok,that means the signal is sent to the child.The child on the other hand prints that it received the signal(that means child's signal handler function is executed ok).
Then the parent never leaves its while(!p1) loop and that's because the child after executing its signal handler command doesn't return to execute the commands in its main function.Here's the child:

Code:

while(!c1){
//do things while not a signal is received
}
cout<<"child reached this point before terminating!!!"<<endl;
kill(getppid(),SIGUSR2); 
cout<<"Child with pid exits "<<getpid()<<endl;

These couts should be executed after the signal handler function but they never do.(the reason I have so many couts is to understand where is the problem).When the child gets the signal from the parent is already somewhere in the while loop.Then why it doesn't return to the first command after the loop?It seems to block and do nothing...

actually I just realized that the child after the signal handler function returns to the main function and inside the loop(as it was already inside when it caught the signal)
but blocks there because there's the command getline() which waits to read from the pipe.It was already blocked there when the signal arrived so it continues from the same point.
But the thing is that the parent doesn't write anything to the pipe anymore
The child looks like:

Code:

while(!c1){
	ifstr.getline(line,LINESIZE); //reads from parent pipe
        //do things
}

so when the signal arrives is blocked,executes the signal handler function and returns to the same point and continues being blocked..
Any ideas to solve that?