Après fork (), où l'enfant commence-t-il son exécution?

J'essaie d'apprendre la programmation UNIX et suis tombé sur une question concernant fork (). Je comprends que fork () crée un processus identique au processus en cours d'exécution, mais où commence-t-il? Par exemple, si j'ai du code

int main (int argc, char **argv)
{
    int retval;
    printf ("This is most definitely the parent process\n");
    fflush (stdout);
    retval = fork ();
    printf ("Which process printed this?\n");

    return (EXIT_SUCCESS);
}

La sortie est:

Il s'agit très certainement du processus parent
Quel processus a imprimé cela?
Quel processus l'a imprimé?

Je pensais que cela fork()créait un même processus, donc j'ai d'abord pensé que dans ce programme, l' fork()appel serait récursivement appelé pour toujours. Je suppose que ce nouveau processus créé à partir de fork()commence après l' fork()appel?

Si j'ajoute le code suivant, pour faire la différence entre un processus parent et enfant,

if (child_pid = fork ()) printf ("This is the parent, child pid is %d\n", child_pid);
else printf ("This is the child, pid is %d\n",getpid ());

après l'appel fork (), où le processus enfant commence-t-il son exécution?

Le nouveau processus sera créé au sein de l' fork()appel, et commencera par y revenir comme le parent. La valeur de retour (dans laquelle vous avez stocké retval) fork()sera:

• 0 dans le processus enfant
• Le PID de l'enfant dans le processus parent
• -1 chez le parent en cas d'échec (il n'y a pas d'enfant, naturellement)

Votre code de test fonctionne correctement; il stocke la valeur de retour de fork()in child_pidet utilise ifpour vérifier si c'est 0 ou non (bien qu'il ne vérifie pas d'erreur)

Je pensais que fork () créait le même processus, donc j'ai initialement que dans ce programme, l'appel fork () serait récursivement appelé pour toujours. Je suppose que le nouveau processus créé à partir de fork () commence après l'appel fork ()?

Oui. Numérotons les lignes:

int main (int argc, char **argv)
{
    int retval;                                               /* 1 */
    printf ("This is most definitely the parent process\n");  /* 2 */
    fflush (stdout);                                          /* 3 */
    retval = fork ();                                         /* 4 */
    printf ("Which process printed this?\n");                 /* 5 */
    return (EXIT_SUCCESS);                                    /* 6 */
}

Le flux d'exécution est le suivant:

caller process     fork() → ...
                          ↘
original program            exec() → 2 → 3 → 4 → 5 → 6
                                               ↘
forked program                                   5 → 6

... ce qui explique exactement la sortie que vous avez reçue.

Si vous voulez savoir comment le programme original et le programme forké peuvent éventuellement se comporter différemment, car ils partagent nécessairement le même code, voir la réponse de Michael Mrozek.

La vraie solution à cela est

switch (fork()) {
    case -1 :
        fprintf (stderr, "fork failed (%s)\n", strerror(errno));
        break;
    case 0 :  // child process comes here
        break;
    default : // parent process
        break;
}

// all continue here

quel que soit le code juste après le fork(), est copié dans le processus enfant, et ne mélangez pas le processus parent et enfant, ce sont deux entités différentes, qui ont le même environnement (dupliqué, non partagé).

Maintenant, voyez votre sortie ...