Fonctionnement de fork

L’auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonsoir,

Je cherche à comprendre le code suivant :

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    pid t pid;
    
    /* fork a child process */
    pid = fork ();

    if (pid < 0) { /* error occurred */
        fprintf(stderr, "Fork Failed");
        return 1;
    }
    else if (pid == 0) { /* child process */
        execlp ("/bin/ls","ls",NULL);
    }
    else { /* parent process */
    /* parent will wait for the child to complete */
        wait (NULL);
        printf("Child Complete");
    }
    return 0;
}

Comment fonctionne la fonction fork() ? Ici wait() et execlp() ne peuvent pas être toutes les deux appelées dans le même process parce qu’elles se trouvent dans la même structure if … else if … else mais sur des branches différentes. Dans ce cas, comment est-ce que le programme peut attendre que son process enfant finisse son travail ? Il doit y avoir une petite subtilité qui m’échappe :euh:

Merci pour votre aide !

+0 -0

Cette réponse a aidé l’auteur du sujet

Salut,

La fonction fork est appelée depuis le processus père, elle peut renvoyer un nombre négatif si elle échoue (il n’y a dans ce cas pas de processus fils). Mais si elle réussit, les programmes père et fils continuent donc juste après l’exécution de cette fonction.

La valeur de retour est alors utile pour les différencier :

  • S’il s’agit d’un nombre non nul, c’est le pid du processus fils, donc on est dans le père.
  • Autrement, on est dans le fils.

Tu gères déjà ces cas avec ta structure conditionnelle.

Ensuite, le processus fils est attendu à l’aide de la fonction wait qui attend que l’un des enfants se termine.

Cette réponse a aidé l’auteur du sujet

Salut,

Lorsqu’un processus appelle la fonction fork(), un nouveau processus est créé, identique au premier. L’exécution des deux processus se fait ensuite indépendamment l’un de l’autre (sauf communication entre processus). La seule chose qui différencie les deux processus est la valeur retournée par la fonction fork() : zéro pour le fils (car il peut connaître son pid via getpid()) et un nombre entier pour le père correspondant au pid de son fils (c’est le seul moyen pour le père de connaître le pid de son fils).

Cette valeur de retour est utilisée pour ensuite différencier le père du fils lors de l’exécution du code. Dans ton cas, le code du fils va être remplacé par celui de l’exécutable /bin/ls et le père va attendre la fin de l’exécution de son fils.

Édit: semi-grilled.

#JeSuisArius

+0 -0

en copiant le pcb ?

Wizix

Je connais mal le sujet mais il me semble que le noyau Linux utilise du copy-on-write, ce qui rend l’opération de fork très peu coûteuse en elle-même (simplement besoin de créer un pid et sûrement quelques autres données).

Édité par entwanne

en copiant le pcb ? Source:Wizix

Je connais mal le sujet mais il me semble que le noyau Linux utilise du copy-on-write, ce qui rend l’opération de fork très peu coûteuse en elle-même (simplement besoin de créer un pid et sûrement quelques autres données).

entwanne

this ^, et qui rend le exec beaucoup plus coûteux par contre. Les mitigations de sécurité comme l’ASLR ne sont appliquées qu’après un exec d’ailleurs.

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte