Discussion :

[shepounet]

Bonjour à tous et à toutes,

Dans une semaine, je vais passer mon partiel de système pour le s3 de DUT informatique. J'ai récupéré un partiel de l'année dernière, parce que ca va faire depuis février qu'on a pas eu cette matière.

J'aimerais avoir un petit coup de main, sur la création de tube et de processus fils. Voilà le sujet de l'année dernière :

Ecrivez un programme C compte.c qui utilise cat, wc et grep pour compter le nombre d'occurence d'un mot dans un fichier dont le nom est donné en paramètre.

Q.A.0.1 :

- Il créé 3 tubes et 2 processus fils (pas de petits-fils), le tube 0 allant du fils 0 au fils 1, le tube 1 allant du fils 1 au père, le tube 2 allant du père au fils 0 (=chainage circulaire)

- Le fils 1 redirige son entrée standard vers le tube 0 et sa sortie standard dans le tube 1. Le père redirige son entrée standard vers le tube 1 et sa sortie standard vers le tube 2. Le fils 0 redirige son entrée standard vers le tube 2.

- Le fils 0 ouvre un fichier dont le nom est donné en argv[2]. il envoie le contenu de ce fichier dans le tube 0. Ensuite, il exécute la commande cat.

- le fils 1 exécute la commande grep sur le mot donné en argv[1]

- Le père exécute la commande wc -l


Est-ce que quelqu'un pourrait me donner quelques informations sur les tubes, leurs fonctionnement... Je ne demande pas un code entier (je sais que ca n'est pas très apprécié), même si je ne serais pas contre ^^

Si quelqu'un peut me filer un tuto ou autre, je le remercie d'avance
Shepounet

[Ubiquité]

T'as dû avoir des TP sur les pipe & co, je te conseil de les faire/re-faire si c'est pas clair.

[Sve@r]

Est-ce que quelqu'un pourrait me donner quelques informations sur les tubes, leurs fonctionnement...

Un tube est simplement un canal de communication avec une entrée et une sortie. On écrit dans le tube avec write() comme on écrirait dans un fichier, et on lit ce qui a été écrit grâce à read().
Le tube peut avoir un support physique (un fichier de type "p" qu'on ira ouvrir avec open et fermer avec close) ou bien être intégralement géré par la mémoire du processus (la primitive pipe() ira créer l'entrée et la sortie et stockera les références de ces 2 canaux dans le tableau passé à la fonction pipe).

Voici un exemple de pipe mémoire. Un père lance un fils et attend une saisie clavier. Tout ce qu'on lui rentre au clavier il l'envoie à son fils via pipe qui l'affiche à l'écran. La saisie s'arrête dès qu'on tape "EOT"

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <sys/mode.h>						// Modes et droits fichiers       
#include <sys/wait.h>						// Attente fin de process         
#include <stdio.h>							// I/O fichiers classiques        
#include <signal.h>							// Signaux de communication       
#include <errno.h>							// Erreurs système                
 
extern const char* const sys_errlist[];		// Liste messages erreurs         
 
#define SZ_STRING			(100)			// Taille message                 
 
// Fonction principale 
main()
{
	// Déclaration des variables 
	int pid;								// No process                     
	int fin_fils;							// No fils fini                   
	int status;								// Etat fin fils                  
	int tube[2];							// Tableau extrémités tube        
 
	char chaine[SZ_STRING];				// Chaine stockage message        
 
	// Création tube memoire 
	if (pipe(tube) != 0)
	{
		fprintf(stderr, "ligne %u - pipe() - %s\n", __LINE__, sys_errlist[errno]);
		exit(errno);
	}
 
	// Création du process fils 
	switch(pid=fork())
	{
		case (-1): // Erreur de fork 
			fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, sys_errlist[errno]); 
			exit(errno);
 
		case 0: // Fils 
			// Fermeture coté inutilisé 
			close(tube[1]);
 
			// Attente que le père ait commençé 
			sleep(1);
 
			// Boucle de lecture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Lecture du tube 
				read(tube[0], chaine, SZ_STRING);
				printf("\tFils(%u) - J'ai reçu '%s'\n", getpid(), chaine);
			}
 
			// Fermeture coté utilisé 
			close(tube[0]);
 
			// Arret du fils 
			printf("\tFils(%d) - Je m'arrête\n", getpid());
			exit(0);
 
		default: // Père 
			// Fermeture coté inutilisé 
			close(tube[0]);
 
			printf("Je suis le père %u de mon fils %u\n", getpid(), pid);
 
			// Boucle d'écriture 
			while (strcmp(chaine, "EOT\n") != 0)
			{
				// Saisie et envoi de la chaine 
				printf("Père(%u) - Entrez une chaine (EOT pour sortir):", getpid());
				fflush(stdin);
				fgets(chaine, SZ_STRING, stdin);
				write(tube[1], chaine, strlen(chaine) + 1);
			}
 
			// Fermeture coté utilisé 
			close(tube[1]);
 
			// Attente mort de mon fils 
			wait(&status);
			printf("Mon fils %u vient de mourir - Mort(%u)\n", pid, WEXITSTATUS(status));
	}
}