Create multiple generations of children process - c

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.