Handling zombies with SIGCHLD - c

Question

In my program, I am listening to incoming SIGCHLD signals to avoid zombies.
Code :
void myhandler(int signo)
{
printf("test");
int status;
pid_t pid;
while((pid = waitpid(-1, &status, WNOHANG)) > 0)
++count;
}
int main(int argc, char const *argv[])
{
struct sigaction sigchld_action;
memset(&sigchld_action,0,sizeof(sigchld_action));
sigchld_action.sa_handler = &myhandler;
sigaction(SIGCHLD,&sigchld_action,NULL);
if(fork() == 0){
exit(0);
}
if(fork()==0){
exit(0);
}
if(fork()==0){
exit(0);
}
while(wait(NULL) > 0)
++count;
return 0;
}
Problem is, number of forked childs and number of output of printf("test") does not match sometimes. Number of forked childs are greater than number printf("test").
Is this code segment guarentees that there will be no zombies? If it is, how it can achieve this? It is not printing the correct number of "test". Is waitpid() clears the dead childs more than once inside the while?
What happens, when this signal handler called, at the same time another child can be died. Signal will blocked by default.(while handler is running, another child can die). Does the waitpid clear the process whose signal sent when signal handler is running?
Also, counter is not equal. (static volatile int) or I tried atomic integer.

Answer 1

Two different things are going on:
printf isn't async-signal-safe, so you shouldn't call it from a signal handler. Replace it with write.
You're only incrementing count once in the signal handler. If you want to know how many processes died, you need to increment it in your while loop instead.
Try this code:
void handler(int signo)
{
int status;
pid_t pid;
while((pid = waitpid(-1, &status, WNOHANG)) > 0) {
write(1, "test", 4); /* technically this may result in a partial write and you should loop it, but in practice I think this'll be fine for this example */
++count;
}
}
With that code, you'll probably have no zombies and have the right number of tests and the right value in count. However, there's one more race condition: if between the final call to waitpid and the end of the signal handler, another child process dies, then no SIGCHLD will be received, so it will be a zombie until the one after it dies too. A solution to this edge case is much more complex and depends on how the rest of your application is structured.