Discussion :

[sin92]

Bonjour voila y'a quelque chose que je n'arrive pas a comprendre je débute dans la programmation système :

voici mon code : il s'agit simplement de faire communiquer un processus père avec un processus fils

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
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void pipe_shell(char* argv1, char* argv2);
 
int main(int argc,char* argv[])
{
        if(argc!=3)
                 exit(-1);
 
	pipe_shell(argv[1],argv[2]);
 
	return EXIT_SUCCESS;
}
 
void pipe_shell(char* argv1, char* argv2)
{
	int tube[2];
	pipe(tube);
	pid_t result_fork=fork();
 
	switch(result_fork)
	{
		case -1 : printf("Erreur creation processus\n");
			exit(-1);
 
		case 0 : /*processus fils*/
                        printf("coucou");
			close(tube[1]);
			dup2(tube[0],0);
			close(tube[0]);
			execl("/usr/bin/sort","sort",NULL);
			break;
 
		default : /*processus pere*/
			printf("coucou");
			close(tube[0]);
			dup2(tube[1],1);
			close(tube[1]);
			execl("/bin/ls","ls",NULL);
 
	}
}

Pourquoi les printf("coucou"); ne s'exécutent pas?

De plus si j'ai bien compris les processus sont tués dès que leurs instructions sont terminés mais admettons que le fils doit envoyer un message au père via un pipe; Admettons que ce soit au père de s'exécuter en premier il va terminer ses instructions, voyant qu'il n'y a rien à lire pour le moment et ne pourra pas lire ce que le fils lui envoie puis va mourir? mais dans la réalité les deux arrivent à communiquer donc quand un processus meurt-il réellement?Tourne t-il en boucle plusieurs fois de suite?Ou lors de l'accès en lecture d'un descripteur va t-il se mettre en pause jusqu'a ce qu'une donnée apparaisse?

Merci !

[Neckara]

Pourquoi les printf("coucou"); ne s'exécute pas?

Ils s'executent au contraire mais la sortie standard est gérée avec un buffer.
On ne vide le buffer pour écrire son contenu lorsque le buffer est plein, lorsqu'on rencontre le caractère '\n' ou lorsqu'on ferme le flux proprement.
Ainsi le buffer est vidé après le dup2 qui redirige la sortie standard vers l'entrée du tube.

De plus si j'ai bien compris les processus sont tués dès que leurs instructions sont terminés mais admettons que le fils doit envoyer un message au père via un pipe; Admettons que ce soit au père de s'exécuter en premier il va terminer ses instructions et ne pourra pas lire ce que le fils lui envoie mais dans la réalité les deux arrivent à communiquer donc quand un processus meurt-il réellement?

execpl ne détruit pas le processus mais effectue un recouvrement.
Ensuite, si le père se termine en premier, il me semble que le fils est adopté par init (à vérifier).

[sin92]

Le truc c'est que si je commente les exec, le printf affiche correctement coucou deux fois.
De plus, printf se situe avant dup donc la sortie n'est pas encore reboucler dans mon tube, elle est encore liée à l'écran non?

Oui si le père meurt le fils est adopté par init mais je me demande concernant la situation suivante : le fils envoie un message au père via un tube, il n'y a aucune boucle, donc toutes les instructions ne seront exécutées qu'une fois. si le père lit le tube avant que le fils n'écrive le message,il aura finit ses instructions et va mourir non? donc comment font-ils pour communiquer? puisque dans la pratique ils communiquent sans problème ?

[plxpy]

Bonjour

en dehors de l'aspect bufferisation pour le "coucou", tes problèmes viennent des lignes 32 et 40.

Dans le fils, à la ligne 32, tu fermes tube[0] qui, depuis le dup2, est ... l'entrée standard. Donc pour lire (dans sort) ...

Idem dans le père : à la ligne 40 tu fermes tube[1] qui est la sortie standard. Là, c'est le "ls" qui va écrire sur stdout ... qui est fermée.

[sin92]

Alors justement ça aussi j'ai pas compris : mon programme simule simplement la commande ls | sort .

Donc je redirige l'entrée de mon dup2 vers la sortie de mon processus ls (processus père) et je redirige la sortie de mon dup2 vers l'entrée de mon processus sort(processus fils) jusque la tout va bien.

Mais les lignes 32 à 40,avec ou sans ces lignes, le programme marche niquel ça m'affiche bien ls | sort sur l'écran.

Mais j'ai cru comprendre que ca faisait plus propre de fermer le dup2 sur les autres extrémités une fois la connection faite va savoir pourquoi...

[plxpy]

Déjà, je suppose que les "coucou" n'étaient là que pour des problémes de débuggage. Si tu les oublies, avec les modifications/suppressions des lignes 32 et 40, le pipe programmé entre ls et sort fonctionne.

Mais les lignes 32 à 40,avec ou sans ces lignes, le programme marche niquel ça m'affiche bien ls | sort sur l'écran.

Ah ben non !!! Si tu les laisses, écrire sur stdout fermée et lire sur stdin fermée posent problème.

Mais j'ai cru comprendre que ca faisait plus propre de fermer le dup2 sur les autres extrémités une fois la connection faite va savoir pourquoi...

Une fois le "dup2(tube[0],0)" exécuté dans le fils, l'entrée standard (0) et tube[0] ne font plus qu'un seul et même "file descriptor". Si tu fermes tube[0] c'est strictement la même chose que de faire, dans le fils, close(0). Donc, soit la personne qui t'a dit que c'était + propre de faire cela n'y connait rien, soit tu as mal compris. Mais le résultat est celui que je décris.

[EDIT] et problème analogue côté père, sur la sortie standard (1 <==> tube[1])