Avoid zombies when father is in a wait of a semaphore - c

Question

This is a strange question. I have 2 different program:
server and client.
server start, alloc all the message queue and start to waitin for a signal from client (the signal is for tell to the server that "there are new message").
the server remain in an infinite loop until recive SIGQUIT.
the client, when casted, start to send a huge number of message to the server
for(;;){//infinite loop
wait(sem,1); //wait for new message
rc = msgctl(msgid, IPC_STAT, &qbuff);
seq_num++;
pid=fork(); //new process for take the message
if(!pid){
if((msgrcv(msgid, &q, msgsz, 1,MSG_NOERROR))== -1)
perror("msgrcv error");
else{
pthread_mutex_lock(&mutex); //start critic sector
printf("\nthere is a prenotation\n");
q.price=get_conf_value(q.kindof_service)+(q.priority*get_conf_value(3)); //costo = costo_visita + (priorità * costo_priorità)
q.turn=seq_num-q.priority; //assign turn
pthread_mutex_unlock(&mutex); //end critic sector
if(q.turn<0)q.turn=0; //controllo del turno che non sia minore di 0
printf("---------------------------");
printf("\nPrenotation number %i\npid caller: %i\npriorità: %i\n for %i\ncost %i\nturn %i\n",seq_num,q.clientId,q.priority, q.kindof_service ,q.price, q.turn);
printf("---------------------------\nPrenotation ok\n\n\n");
}
printf("\nsuccess.\n");
exit(1); //close children process
}
}
The problem is that, in this way the father leave so much zombies. If i add
else{//i am the father
waitpid(pid, 0, 0);
}
there is the problem that the primary process fork, then wait until the child is ended, then fork again.
i need that the father fork so many time and that dont wait the end of the process before fork again.
But without the waitpid the problem is another.. because after that he start all the process needed for receive all the message, the father take the control and still waitin for another signal from the client (the first wait(sem,1) ), leaving so much zombie process.
I don't know if I explained it well.. is very difficult in english -_-
So, i want a server that, received the signal, fork many many times. any child take a message and do some stuff, then the child end. Meanwhile the server continue to wait for new incoming message. All without make zombies :)

Answer 1

One way to fire-and-forget processes without having to worry about zombies is to fork twice.
Each process has a parent process. If the parent process exits before the child does, the child is becoming an orphan, and is inherited by init (process 1) - which will wait for all children, preventing them to become zombies without manual work.
So what you can do is to fork, and fork yet again in the child process. Then, you can let the child exit, which will cause the grandchild (where you do your work) to be inherited by init. The parent process can wait for the child (which won't take long, because the child did nothing else than fork and exit). When the grandchild is exiting, init will automatically wait for it.
/* fire and forget */
int execute_detached(char **cmdline)
{
pid_t pid;
if((pid = fork()) < 0) { /* fork error */
perror("fork");
return 0;
}
else if(pid > 0) { /* parent */
waitpid(pid, NULL, 0);
return 1;
}
else { /* child */
if((pid = fork()) < 0) { /* fork error */
perror("fork");
return 0;
}
else if(pid > 0) { /* child */
/* make grand child an orphan */
_exit(0);
}
else { /* grand child */
execvp(cmdline[0], cmdline);
perror("execvp");
_exit(1);
}
}
return 0;
}