Create multiple generations of children process

Question

So I'm trying to understand the concept of grandchildren. I'm able to create a given number of sons (i.e brothers) but I don't know how to create multiple generations . This is what I did to create one grandson :

int main ()
{
//Displaying the father
printf("Initial : Father = %d\n\n", getpid()); 

/****** FORK *******/

pid_t varFork, varFork2;

varFork = fork();

if(varFork == -1) //If we have an error, we close the process
{
    printf("ERROR\n");
    exit(-1);
}
else if (varFork == 0) //if we have a son, we display it's ID and it's father's
{
    printf("SON 1\n");
    printf(" ID = %d, Father's ID = %d\n", getpid(), getppid());

    varFork2 = fork();//creation of the second fork

    if(varFork2 == -1) //If we have an error, we close the process
    {
        printf("ERROR\n");
        exit(-1);
    }
    else if (varFork2 == 0) //now we have the son of the first son, so the grandson of the father
    {
        printf("\nGRANDSON 1\n");
        printf(" ID = %d, Father's ID = %d\n", getpid(), getppid());
    }
    else sleep(0.1);/*we wait 0.1sec so that the father doesn't die before we can 
        display it's id (and before the son process gets adopted by a user process descending from the initial              process)*/  
}
else //in the other case, we have a father
{
    sleep(0.1);//again we put the father asleep to avoid adoption
}
return 0;
}

How can I create X generations of grandsons, X being a global variable (1son, 1 grandson, 1 great-grandson, etc.) ?

Answer 1

How can I create X generations

Before forking, decrement X and continue forking inside the child until X is 0.

Or inside the child decrement X and only continue forking if after decrementing it X still is greater 0.

The code might look like this:

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>

void logmsg(const char *, int);

#define MAX_GENERATIONS (4)

int main(void)
{
  pid_t pid = 0;

  for (size_t g = 0; g < MAX_GENERATIONS; ++g)
  {
    logmsg("About to fork.", 0);

    switch (pid = fork())
    {
      case -1:
      {
        logmsg("fork() failed", errno);

        break;
      }

      case 0:
      {
        logmsg("Hello world. I am the new child.", 0);

        break;
      }

      default:
      {
        char s[1024];
        snprintf(s, sizeof s, "Successfully created child carrying PID %d.", (int) pid);
        logmsg(s, 0);
        g = MAX_GENERATIONS; /* Child forked, so we are done, set g to end looping. */

        break;
      }
    }
  }

  logmsg("Sleeping for 3s.", 0);
  sleep(3);

  if (0 != pid) /* In case we forked a child ... */
  {
    logmsg("Waiting for child to end.", 0);
    if (-1 == wait(NULL)) /* ... wait for the child to terminate. */
    {
      logmsg("wait() failed", errno);
    }
  }

  logmsg("Child ended, terminating as well.", 0);

  return EXIT_SUCCESS;
}

void logmsg(const char * msg, int error)
{
  char s[1024];
  snprintf(s, sizeof s, "PID %d: %s", (int) getpid(), msg);
  if (error)
  {
    errno = error;
    perror(s);
    exit(EXIT_FAILURE);
  }

  puts(s);
}

The output should look similar to this:

PID 4887: About to fork.
PID 4887: Successfully created child carrying PID 4888.
PID 4887: Sleeping for 3s.
PID 4888: Hello world. I am the new child.
PID 4888: About to fork.
PID 4888: Successfully created child carrying PID 4889.
PID 4888: Sleeping for 3s.
PID 4889: Hello world. I am the new child.
PID 4889: About to fork.
PID 4889: Successfully created child carrying PID 4890.
PID 4890: Hello world. I am the new child.
PID 4890: About to fork.
PID 4889: Sleeping for 3s.
PID 4890: Successfully created child carrying PID 4891.
PID 4890: Sleeping for 3s.
PID 4891: Hello world. I am the new child.
PID 4891: Sleeping for 3s.
PID 4888: Waiting for child to end.
PID 4890: Waiting for child to end.
PID 4891: Child ended, terminating as well.
PID 4890: Child ended, terminating as well.
PID 4887: Waiting for child to end.
PID 4889: Waiting for child to end.
PID 4889: Child ended, terminating as well.
PID 4888: Child ended, terminating as well.
PID 4887: Child ended, terminating as well.

The difference with my code above compared to the proposal I made is that it counts upwards to X.