複数世代の子プロセスを作成する

Question

私は孫のコンセプトを理解しようとしています。 私は与えられた数の息子（つまり兄弟）を作成することができますが、私は複数の世代を作成する方法を知らない。 これは私が1人の孫を作成するためにやったことです：

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; 
} 

どのように私は孫のX世代を作成することができ、Xグローバル変数（1sonなど1人の孫、1ひ孫、）であること？

Answer 1

が、私はフォークの前にX世代

を作成することができますどのように、Xをデクリメントし、Xが0になるまで子の内側フォーク続けます。

または子の中でXを減らしてから、それを減らした後にフォークを続けるとXは依然としてより大きい0です。

コードは次のようになります。

#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); 
} 

出力は次のようになります。

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. 

を私が作った案に比べて上記の私のコードとの違いは、それが上向きにカウントしていることですXに