Discussion :

[abdoulbassit7]

le programme doit créer des processus en utilisant la fonction fork() et a chaque création afficher le pid du processus créer et le pid du processus parent.
les créations doivent être faites selon l'ordre généalogique suivante : P1 , P2 P3 P4 créer à partir P1 et P4 P5 créer à partir de P4



mon code sources pour la création des processus P2, P3, et P4 à partir de P1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
#include <unistd.h>
 
int main(int argc, char const *argv[]) {
 
  printf("pid P1 : %d\n", getpid());// Affichage du pid de P1 
 
  pid_t P2 = fork(); // création de P2
  if(P2 == 0)
  {
    printf("pid P2 : %d, pid parent P1 : %d\n", getpid(), getppid());
  }
  pid_t P3 = fork();
  if(P3 == 0)
  {
    printf("pid P3 : %d, pid parent P1 : %d\n", getpid(), getppid());
  }
 
  pid_t P4 = fork();
 
  if(P4 == 0)
  {
    printf("pid P4 : %d, pid parent P1 : %d\n", getpid(), getppid());
  }
 
  return 0;
}

voila ce que j'ai après exécution :

pid P1 : 12544

pid P2 : 12545 pid parent P1 : 12544
pid P3 : 12546 pid parent P1 : 12544
pid P4 : 12547 pid parent P1 : 12544

pid P3 : 12548 pid parent P1 : 12545
pid P4 : 12549 pid parent P1 : 12546
pid P4 : 12550 pid parent P1 : 12545
pid P4 : 12551 pid parent P1 : 12548

maintenat j'arrive pas à comprendre pourquoi il y'a d'autre affichage après l'affichage du PID de P2, P3, P4 et celui de leur parent P1. Comment je pourrai résoudre ce problème.

Aidez moi svp

[xZene]

Je n'ai commencé la programmation système que très récemment mais de ce que je me souviens c'est que en gros le fork va créer un processus fils: Ce processus reprendra l'execution du programme à partir de là où lui commence. Ainsi ton programme père va faire P2 puis P3 puis P4 tandis que son fils P2 reprendra là où il commence c'est à dire qu'il créera P3 puis P4 (Et idem pour P3 & P4). (Désolé si c'est pas super clair)

Maintenant pour résoudre le problème il me semble qu'il suffise de faire un exit, ça donnerait ça par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
pid_t P2 = fork(); // création de P2
switch(P2){
 case -1:
  printf("Erreur lors du fork\n");
  break;
 case 0: 
  printf("pid P2 : %d, pid parent P1 : %d\n", getpid(), getppid());
  exit(0);
  break;
}

Je n'ai pas testé le code, ce n'est peut-être qu'une résolution partielle de ton problème.

[Sve@r]

Bonjour

maintenat j'arrive pas à comprendre pourquoi il y'a d'autre affichage après l'affichage du PID de P2, P3, P4 et celui de leur parent P1.

Parce que tu n'as pas intégré le fait que le fork() duplique absolument tout le code placé après. Et donc ok tester le cas 0 (fils) te permet de cibler où tu es, mais ensuite un code placé hors test sera alors lui-aussi dupliqué et exécuté deux fois
Exemple

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if (fork() == 0) {
    printf("Fils\n");
}
printf("Hello\n");

Le "Hello" sera affiché 2 fois (par le père et par le fils). Et ici c'est exactement la même chose. P3=fork() a été exécuté par le père et aussi par le premier fils P2. Et donc P1 crée un fils P2 puis un fils P3 mais P2 crée aussi un autre P3. Et etc etc quand le code continue.

Comment je pourrai résoudre ce problème.

Première solution: tout le code qui suit chaque fork() est définitivement isolé dans le if ou le else
Exemple

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
if (fork() == 0) {
    // Premier fils
    printf("Fils 1\n");
} else {
    // Père
    if (fork() == 0) {
        // Second fils
        printf("Fils 2\n");
    } else {
        // Le père continue ici
        if (fork() == 0) {
            // Troisième fils
            printf("Fils 3\n");
        } else {
            // Le père continue ici
           ...
        }
        // Aucun code ici sinon il sera exécuté par le 3° fils et le père
    }
    // Aucun code ici sinon il sera exécuté par le 3° fils et le 2° fils et le père
}
// Aucun code ici sinon il sera exécuté par le 3° fils et le 2° fils et le 1er fils et le père

Seconde solution: le fils s'arrête en fin de travail

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if (fork() == 0) {
    // Premier fils
    printf("Fils 1\n");
    exit(0);
}
// Ici le fils1 s'est arrêté et le père continue seul
 
if (fork() == 0) {
    // Second fils
    printf("Fils 2\n");
    exit(0);
}
// Ici le fils2 s'est arrêté et le père continue seul
 
if (fork() == 0) {
    // Troisième fils
    printf("Fils 3\n");
    exit(0);
}
// Ici le fils3 s'est arrêté et le père continue seul
...

(Désolé si c'est pas super clair)

Sisi, moi j'ai compris (enfin comme je le savais déjà peut-être que ça m'a aidé aussi )
Mais c'est bien ça, tu as bien compris le fork()

[abdoulbassit7]

j'ai très bien compris, merci énormément à vous tous pour le temps consacrer pour m'aider, les réponses sont bien expliquées et m'on aider à mieux comprendre le fonctionnement des processus. Je veux savoir à quoi sert la fonction pause() et exec() dans fonctionnement des processus

[Sve@r]

Je veux savoir à quoi sert la fonction pause() et exec() dans fonctionnement des processus

Ben tu ouvres ton cours, ou bien tu tapes man pause et/ou man exec dans un shell.
La fonction pause() met le processus qui l'invoque en attente jusqu'à ce qu'il reçoive un signal (kill()). Un souci majeur dans ce genre de programmation, c'est que pour 99% des signaux, le processus qui le reçoit meurt dès réception. Donc quand il est en pause, il reçoit un signal, il se réveille et meurt ce qui est super con. Il faut alors lui rajouter un outil d'interception de signal (signal()) pour qu'il puisse se réveiller sans mourir.

Les fonctions de la famille exec() (parce qu'il y en a plusieurs) servent à remplacer le processus qui les invoque par le programme demandé dans la fonction. C'est comme cela que l'on programme un shell. Quand le programme shell lit une commande au clavier, il se duplique (fork()). Le père se met alors en attente jusqu'à la fin du fils tandis que le fils remplace son code (le shell dupliqué donc) par la commande demandée.
C'est grâce à cet ingénieux système qu'on peut alors exécuter une commande en arrière plan via le "&" placé en fin de ligne. Dans ce cas, le père n'attend plus la fin de son fils, il revient immédiatement au prompt pour attendre la commande suivante.

[abdoulbassit7]

Merci !!