Pipe, fork & Select

Version imprimable

Pipe, fork & Select

Bonjour,

je dois faire un programme qui contient deux processus qui communiquent via des pipes. Le processus fils doit à la fois pouvoir lire sur un pipe et écrire sur un autre. Concrètement le fils doit envoyer une commande au père, qui l'exécute et écrit le résultat sur un autre pipe, puis le fils doit de nouveau lire sur l'autre pipe le résultat pour l'afficher. Pour cela j'utilise select() de cette façon:
Code:

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 pipe(pr); pipe(pw); ... fd_set r_fdset, w_fdset; FD_ZERO(&r_fdset); FD_ZERO(&w_fdset); FD_SET(pr[1], &w_fdset); FD_SET(pw[0], &r_fdset); max = (pr[1] > pw[0]) ? pr[1] : pw[0]; while(1) { state = select(max+1, &r_fdset, &w_fdset, NULL, NULL); if(state == -1) perror("select"); else if(state > 0) { if (FD_ISSET(pr[1], &w_fdset)) { printf("Ecriture\n"); } if (FD_ISSET(pw[0], &r_fdset)) { printf("Lecture\n"); } } else { printf("Rien\n"); } } ...
Le problème que j'ai est que le select() ne retourne jamais avec la lecture possible sur pw[0]. J'ai essayé beaucoup de chose mais j'obtiens toujours un Bad file descriptor.

Merci pour voter aide.

23/04/2012, 12h53
kwariz

Salut,

as-tu ouvert les deux pipes en lecture et en écriture (c'est obligatoire, même si tu n'utilises qu'un bout) dans le père et le fils ?
23/04/2012, 20h52
alexgille

La fonction pipe() ouvre les deux pipes avant le fork(). Pour l'instant je ferme aucune des extrémités du pipe que ce soit dans le père ou dans le fils.
24/04/2012, 13h22
Neckara

Tu ne teste pas la valeur de retour de certaines fonctions (comme int pipe(int [2]) ).

Ensuite, je ne suis pas sûr, mais select peut-il regarder deux tubes à la fois?
Je dois avouer que je n'ai jamais eu à l'utiliser.

voici un example, mais en utilisant la methode poll():

Code:

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
 
#include <stdio.h>
#include <fcntl.h>
#include <poll.h>
#define MAX_BUFF_SIZE 128
 
int main(void){
    char buff[MAX_BUFF_SIZE + 1];
    char *buf = NULL;
    int fd = -1;
    int ret = -1;
    int len = 0;
    struct pollfd fdinfo[1];
 
    if((fd = open("/home/s/pipe", O_RDONLY)) == NULL) {
        printf("Error Opening File.\n");
        exit(1);
    }
 
    fdinfo[0].fd = fd;
    fdinfo[0].events = POLLIN|POLLPRI ;
 
    while(1)
    {
        ret = poll(fdinfo,1,-1);
        if (ret < 0) printf("\n\r error");
 
        if ( ((fdinfo[0].revents&POLLIN) == POLLIN) || ((fdinfo[0].revents&POLLPRI) == POLLPRI) )
        {
            len = read(fdinfo[0].fd, buff, MAX_BUFF_SIZE);
            if (len > 0){
                buff[len] = '\0';
                buf = (char *) calloc(1, len+1);
                memcpy(buf, buff, len);
                printf("\n read len %d\n %s",len, buf);
                free(buf);
             }
        }
 
    }
    return 0;
}

24/04/2012, 14h28
alexgille

En réalité je test la sortie de la fonction pipe. Mais pour plus de simplicité je ne l'ai pas mis dans le poste.

Pour ce qui est de la fonction poll(), je suis contraint d'utiliser select() :/

Merci :)

Je pense que le problème est que select() ce bloque !!!

Citation:

timeout is an upper bound on the amount of time elapsed before select() returns. If both fields of the timeval structure are zero, then select() returns immediately. (This is useful for polling.) If timeout is
NULL (no timeout), select() can block indefinitely.

Il y a la structure suivante qu'il faut utiliser :
Code:

1 2 3 4 5 6 7 8 9 struct timeval { long tv_sec; /* seconds */ long tv_usec; /* microseconds */ }; /* Wait up to five seconds. */ tv.tv_sec = 5; tv.tv_usec = 0;
Est ce que ton programme se bloque ?

24/04/2012, 17h58
alexgille

Si je fais un "ps -aux" je ne trouve pas de trace de mon programme, donc je pense qu'il sort et se termine "normalement".

De plus le select() me renvoie le message d'erreur "Bad file descriptor" lorsque je test la valeur de sortie de select(). Ce qui veut dire que select() ne se bloque pas. Enfin je pense.. :?
24/04/2012, 19h49
Neckara

Select est bloquant (sauf si on lui indique un temps de timeout).

Mais ton select ne bloque pas car il retourne une erreur, "bad file descripteur" signifie que tu passe en paramètre à ton select un descripteur de tube invalide.

Descripteur stocké dans pr[0], pr[1], pw[0] ou pw[1]
24/04/2012, 20h53
alexgille

Oui, ça je l'avais compris :P
Maintenant je cherche une solution, vu que mes tubes sont forcement ouverts..sinon les deux appels à pipe() auraient renvoyé une erreur.
24/04/2012, 21h32
Neckara

Essaye de faire le select sur un seul des descripteurs pour voir si le problème vient d'un des descripteurs et affiche le n° des descripteur et celui de max régulièrement.

J'ai relu le man de select et il me semble que tu as tout fait correctement, donc à part afficher les valeurs des variables qui peuvent poser problème, je ne vois pas trop quoi faire.

~~NB : Erreur bête, est-ce que tu n'aurais pas inversé les descripteurs de lecture et d'écriture?~~

EDIT : non même pas, je suis vraiment perplexe.
24/04/2012, 21h35
alexgille

Si je ne trompe pas on lit sur p[0] et on écrit sur p[1] non? :koi:
J'ai mis pr[1] dans un fd_set qui va directement dans le bon argument de select() et pw[0] dans un autre fd_set qui va dans l'autre argument de select().
24/04/2012, 21h44
Neckara

Franchement à part tenter de faire avec un seul descripteur de fichier pour savoir quel descripteur est invalide et vérifier si max a la bonne valeur...

J'ai beau relire le man, je ne vois pas ce qui cloche.

Peut être revérifier d'avoir tout inclus les bibliothèques correctement (?)
27/04/2012, 19h02
alexgille

Pour ce qui est de la valeur de max, j'ai essayé de la faire recalculer à chaque itération, mais ça ne change rien.

Lorsque j'utilise select() avec un fdset en lecture ou en écriture ça passe niquel. Quand j'utilise les deux en même temps, blocage et rien ne bouge.
27/04/2012, 20h30
Obsidian

Il y a un truc qui me saute aux yeux tout de suite, c'est qu'il faut refaire FD_SET à chaque tour. Avant chaque appel à select(), pour être exact.

select() se sert des mêmes sets pour savoir d'abord quels descripteurs il doit surveiller et pour indiquer, ensuite, lesquels se sont débloqués. Donc, les FD_SET effectués au préalable sont perdus une fois l'appel à select() terminé.

J'ai aussi tenté cette solution, sans succès. J'avoue que je ne comprend pas pourquoi select() déconne quand on lui donne 2 fd_set différents.

Voici le code que j'ai essayé:

Code:

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
int pr[2], pw[2], output_fd;
 
	if (argc < 2) {
		printf("ERREUR: Arguments invalides\n");
		return EXIT_FAILURE;
	}
 
	if ((pipe(pw) < 0) || (pipe(pr) < 0) || (output_fd = open(FILE, O_WRONLY | O_CREAT, 0600)) < 0) {
		perror("init");
		return EXIT_FAILURE;
	}
 
	if (fork() > 0) {
		int n, state, nfds = 0;
		fd_set r_fdset, w_fdset;
		struct timeval dt = {5, 0};
 
		while (1) {
			FD_ZERO(&r_fdset);
			FD_ZERO(&w_fdset);
			FD_SET(pr[1], &w_fdset);
			FD_SET(pw[0], &r_fdset);
 
			nfds = (pr[1] > pw[0]) ? pr[1] : pw[0];
			state = select(nfds+1, &r_fdset, &w_fdset, NULL, &dt);
 
			if (state == -1) {
				perror("select()");
				break;
			} else if (state > 0) {
 
				if (FD_ISSET(pw[0], &r_fdset)) {
					char c[10];
 
					read(pw[0], c, 5*sizeof(char));
					printf("Arrive %s\n", c);
 
					break;
				}
 
				if (FD_ISSET(pr[1], &w_fdset)) {
					printf("Depart\n");
					write(pr[1], "test", 5*sizeof(char));
 
					/* Fermeture du pipe */
					close(pr[1]);
				}
			} else {
				printf("Timeout\n");
				break;
			}
		}
 
 
	} else { /* Executeur */		
		char c[10];
		int n;
 
		n = read(pr[0], c, 5*sizeof(char));
		printf("Choppe %s\n", c);
		write(pw[1], c, n);
	}

Certains close() ont étés volontairement omis.
Ce code ne fonctionne pas.

28/04/2012, 20h19
Obsidian

Il fonctionne en partie : ta boucle fait plusieurs tours mais tu ne t'en rends pas compte.

D'abord, un pipe est doté d'un buffer. Par défaut, tu peux écrire jusqu'à 4096 octets dedans avant qu'il passe en mode bloquant si le lecteur ne lit pas en parallèle. Ça signifie que ton premier appel à select() va automatiquement se débloquer même si le processus fils n'a pas encore démarré. Bon, en l'occurrence, il commence par un read() donc le résultat est le même.

Ensuite, ligne 46, tu fais un « close pr[1] », c'est-à-dire que tu refermes le tube dans lequel tu viens d'écrire. Au tour de boucle suivant, tu refais un select() sur le même descripteur. Son numéro est toujours dans le tableau parce qu'il n'y a pas de raison qu'il en ait disparu, mais il ne correspond plus à rien et select() se plaint en te renvoyant un « Bad File Descriptor ».

Je pensais que ça pouvait venir de là mais je n'en étais pas sûr.

Néanmoins j'ai trouvé une solution à mon problème.

Code:

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
if (fork() > 0) {
		int n, state, nfds = 0;
		fd_set r_fdset, w_fdset;
		struct timeval dt = {5, 0};
 
		/* Set pour le select */
		FD_ZERO(&r_fdset);
		FD_SET(pw[0], &r_fdset);
 
		printf("Depart\n");
		write(pr[1], "test", 5*sizeof(char));
 
		/* Fermeture du pipe */
		close(pr[1]);
 
		state = select(pw[0]+1, &r_fdset, NULL, NULL, &dt);
 
		if (state == -1) {
			perror("select()");
			return EXIT_FAILURE;
		} else if (state > 0) {
			if (FD_ISSET(pw[0], &r_fdset)) {
				char c[10];
 
				read(pw[0], c, 5*sizeof(char));
				printf("Arrive %s\n", c);
			}
		} else {
			printf("Timeout\n");
			return EXIT_FAILURE;
		}
 
 
	} else { /* Executeur */		
		char c[10];
		int n;
 
		n = read(pr[0], c, 5*sizeof(char));
		printf("Choppe %s\n", c);
		write(pw[1], c, 5*sizeof(char));
	}
 
	close(output_fd);
 
	return EXIT_SUCCESS;

Par contre je me demande ce qu'il se passerait si le retour du fils arrivait avant l'appel du select().