How can you make a parent process wait for a child? I'm gettin a seg fault.

Hi guys,

For some reason my application is doing a seg fault when I tell the parent to wait for the child to be done with the process.
Here is the output:
andorian 73% pr5 -a 3 -s 10 -c 1

child_alarm_time = 3
child_processes = 1
child_sleep_time = 10
Installed SIGALRM, SIGINIT,SIGCHLD signals
18740: Tue Oct 14 02:57:45 2008 alarm signal received
18740: Tue Oct 14 02:57:48 2008 alarm signal received
18740: Tue Oct 14 02:57:51 2008 alarm signal received
18740: Tue Oct 14 02:57:52 2008 here is child 0
18740: Tue Oct 14 02:57:52 2008 Killing this child process. 0
18739: Tue Oct 14 02:57:52 2008 child signal received - ignored
Segmentation fault

I also get the seg fault if I do the following:
pr5 -c 1
pr5 -c 2


Here is my code

Code:

static void Sleep(int alarm_time_interval, int total_sleep_time)
{
	int remaining_sleep_time = total_sleep_time;

	while (remaining_sleep_time > 0)
	{
		if (alarm_time_interval > 0)
		{ alarm(alarm_time_interval); }
		remaining_sleep_time = sleep(remaining_sleep_time);
	}
}

/*----------------------------------------------------------------------------*/

/* The functions in this section are intended to demonstrate various usages and
* properties of signals and signal handlers.  They should be removed or modified
* in the final version of the program.
*/

static void generic_signal_handler(int sig)
{
	print_message_1("generic_signal_handler, signal", sig);
}

static void SIGALRM_handler(int sig)
{
	if (sig == SIGALRM)
	{ print_message("alarm signal received"); }
	else
	{ print_message_1("serious error: SIGALRM_handler, received signal", sig); }
}

static void SIGINT_handler(int sig)
{
	if (sig == SIGINT)
	{ print_message("interrupt signal received - ignored"); }
	else
	{ print_message_1("serious error: SIGINT_handler, received signal", sig); }
}

static void SIGCHLD_hanlder(int sig)
{
	if(sig == SIGCHLD)
	{ print_message("child signal received - ignored"); }
	else
	{ print_message_1("serious error: SIGCHLD_handler, received signal", sig); }
}



#ifndef NSIG
#define NSIG 64
#endif

static int generic_signal_handler_installed[NSIG];
/* signal 0 is reserved
* the default handlers for SIGKILL and SIGSTOP cannot be replaced
*/

/* try to replace every default signal handler */
static void signal_setup(void)
{
	/* int i, ret;

	for (i = 0; i < NSIG; i++)
	{
	ret = install_signal_handler(i, generic_signal_handler);
	generic_signal_handler_installed[i] = (ret == 0);
	}*/


	printf("Installed SIGALRM, SIGINIT,SIGCHLD signals\n");
	//just set up these 3 signal handlers
	install_signal_handler(SIGALRM, SIGALRM_handler);
	install_signal_handler(SIGINT, SIGINT_handler);
	install_signal_handler(SIGCHLD,SIGCHLD_hanlder);
}


/*----------------------------------------------------------------------------*/

int main(int argc, char *argv[])
{
	
	//set up the signal handlers
	signal_setup();

	//check to see if no arguments were passed, if there weren't then don't
	//create any children

	//fork children based on what is passed through the command line
	pid_t child_pid;

	//holds an array of the child processes so the parent can wait for them.
	pid_t child_array[MAX_CHILDREN];

	int CHILD_STAT;

	//print_process_table("Table before forking.");

	//creating processes
	for(int i =0; i < child_processes; i++)
	{
		child_pid = fork();
		child_array[i] = child_pid;


		if(child_pid == (pid_t)(-1))
		{
			//this is the parent process.  The fork failed, and there is no child
			print_message_error("fork()", strerror(errno));
			exit(EXIT_FAILURE);
		}
		else if(child_pid == 0)
		{
			//this is a child process.  The fork worked
			//checking to see if alarm/sleep flags were set
			if(a_flag || s_flag)
			{
				Sleep(child_alarm_time,child_sleep_time);
			}
			
			print_message_1("here is child ",i);
			print_message_1("Killing this child process.",i);
			exit(child_exit_status);
		}
		else
		{
			//print_message("here is the parent, all children created.");
			//if this flag is set, then set the parent alarm/sleep 
			if(b_flag || t_flag)
			{
				//set alarm
				//printf("set the alarm: %d set sleep: %d for the process: %d\n",parent_alarm_time,parent_sleep_time,getpid());
				Sleep(parent_alarm_time,parent_sleep_time);
			}

			//this is a parent process.  The fork worked
			//add more code but do not exit yet
			//Wait for the child process to be done
			wait_child(child_pid,CHILD_STAT);


			

			//update the process table
			//printf("added child process %d\n", child_pid);
			insert_process_table(child_pid);
			//print_process_table("Table after inserting the process in parent.");

			//print_process_table("Parent calling this again");
		}
	}

	//tried this didn't work 
	/*for(int i = 0; i < child_processes; i++)
	{
		wait_child(child_array[i],CHILD_STAT);

	}*/

	print_message("here is the parent, all children created");


	if(b_flag || t_flag)
	{
		//set alarm
		//printf("set the alarm: %d set sleep: %d for the process: %d",parent_alarm_time,parent_sleep_time,getpid());
		Sleep(parent_alarm_time,parent_sleep_time);
	}

	return EXIT_SUCCESS;

So basically I'm getting this when I try to create a 1 or more child processes and I tell the parent to wait for the child to be done, so the wait_child is where the error has to be at and I"m not sure why.

My guess is that I'm killing the process and then asking it to wait for a dead process?

Here is what the child_wait process looks like:

Code:

#include <errno.h>

/* for waitpid(2) and wait(2) */
#include <sys/types.h>
#include <sys/wait.h>

#include "pr5_wait.h"

/*----------------------------------------------------------------------------*/

/* wait for a child process whose pid you know
 *
 * return 1 if a child was found
 *    *child_status has been updated, and the child has terminated
 *
 * return 0 if no child was found
 *    *child_status has not been updated
 */

int wait_child(pid_t wait_pid, int *child_status)
{
  int s;

  /* loop because waitpid() can be interrupted by a signal and return early */

  while (waitpid(wait_pid, &s, 0) == (pid_t)(-1))
    {
      if (errno == ECHILD)		/* no more children */
        { return 0; }
    }

  *child_status = s;

  return 1;
}

/*----------------------------------------------------------------------------*/

/* wait for a child process whose pid you do not know
 *    if more than one child has terminated, report only one
 *
 * return 1 if a child was found
 *    *wait_pid and *child_status have been updated, and the child has terminated
 *
 * return 0 if no child was found
 *    *wait_pid and *child_status have not been updated
 */

int wait_any_child(pid_t *wait_pid, int *child_status)
{
  pid_t w;
  int s;

  /* loop because wait() can be interrupted by a signal and return early */

  while ((w = wait(&s)) == (pid_t)(-1))
    {
      if (errno == ECHILD)		/* no more children */
        { return 0; }
    }

  *wait_pid = w;
  *child_status = s;

  return 1;
}

/*----------------------------------------------------------------------------*/

That code is correct, I"m just using it wrong I think.

Any help would be great.

This compiles without errors?

int CHILD_STAT;
...
wait_child(child_pid,CHILD_STAT);
...
int wait_child(pid_t wait_pid, int *child_status)

As in, the function expects a POINTER, and you don't pass one.

I've been learning about fork() lately and here's too really short examples (one that works and one that doesn't, but may seem to).

Example #1: Using signal handler

Code:

#include <stdio.h>
#include <signal.h>

void handler () {
	puts("child done!");
}

int main() {
	short int i;
	pid_t parent=getpid(), child;
	signal(SIGUSR1,handler);
	if (fork()==0) {
		sleep(3);
		kill(parent,SIGUSR1);
		return;
	}
	for (i=0;i<5;i++) {sleep(1);puts("...");
                fflush(stdout);}
	puts("parent done");
}

Output:
...
...
child done!
...
...
...
parent done

Example #2: Using return value

Code:

#include <stdio.h>

short int forkchild () {
	if (fork()==0) {
		sleep(3);
		return 1;}
	else return 0;
}	

int main () {
	short int retv=forkchild(),i;
	if (retv==1) {puts("child done");return;}
	for (i=0;i<5;i++) {sleep(1);puts("...");}
	puts("parent done");
}

Output:
...
...
child done
...
...
...
parent done

A useful element of example #2 is how the child is prevented from running main again when it returns (this had me looped for a while; try removing the red return).

fflush() in the first example is not totally necessary but it may prevent the "put" lines from appearing after a delay or all at once.

thanks the solution was to add wait_any_child rather than use wait_child