Tube FIFO est toujours lisible dans le select()

En C pseudo-code:

while (1) {
    fifo = open("fifo", O_RDONLY | O_NONBLOCK);
    fd_set read;
    FD_SET(fifo, &read);
    select(nfds, &read, NULL, NULL, NULL);
}

Le processus dort déclenchée par select() jusqu'à ce qu'un autre processus écrit dans fifo. Par la suite, il sera toujours à trouver fifo comme un fichier lisible par descripteur.

Comment éviter ce problème (qui est, après fifo a été lu une fois, comment faire il faut trouver comme illisible jusqu'à ce qu'il obtient une autre écriture?)

Alors, que voulez-vous produire?

OriginalL'auteur Matoe | 2013-01-30

  1. 31

    Vous ouvert que le FIFO en lecture seule (O_RDONLY), quand il n'y a aucun écrivain de la FIFO, la lecture de la fin recevrez un EOF.

    Sélectionnez le système d'appel sera de retour sur EOF et pour chaque EOF vous poignée, il y aura un nouveau EOF. C'est la raison pour laquelle le comportement observé.

    Pour éviter cette ouverture que FIFO pour la lecture et l'écriture (O_RDWR). Cela garantit que vous avez au moins un écrivain sur la FIFO ainsi, il ne sera pas un EOF et comme un résultat de select ne renvoie pas à moins que quelqu'un écrit à cet FIFO.

    C'était la bonne réponse à empêcher l'exécution d'une boucle sans fin de la fin de vie de détection
    c'était la bonne réponse pour moi. Bien que, dans mon cas, j'ai eu des petits variante: pipe retourne toujours 2 fds - 1 pour la lecture et 1 pour l'écriture; dans mon cas, j'ai explicitement fermé la fin d'écriture (exemple de code suivant à partir d'un C/S de l'application). Donc, j'ai rencontré le même problème que la lecture de la fin était toujours prêt à lire à cause de l'EOF. MERCI POUR L'ASTUCE
    OMG, je cherchais quelque chose comme ça pour littéralement de 4 heures. Enfin trouvé la solution ici. +1
    quand je fais cela, je n'ai jamais enregistrer une réponse dans la sélection du bloc de l'écriture, à la fin de la fifo. il a juste étals de. Même si je chaîne de redirection à partir de la borne de la fifo, j'ai toujours rien

    OriginalL'auteur Fox

  2. 3

    La réponse la plus simple est de lire jusqu'à la read() retourne EWOULDBLOCK (ou EAGAIN), ou le craps avec une erreur.

    Ce que vous dites ne peut tout simplement pas se produire à moins que le système d'exploitation (ou d'exécution) que vous utilisez est buggé. Sinon, vous devez être en train de faire quelque chose de mal. Par exemple, select() est à l'aide déclenché par le niveau I/O. je pense que, probablement, vous n'êtes pas le drainage de la prise complètement, et ainsi de select() indique toujours que vous avez quelque chose à gauche (cela n'arrive pas avec edge-triggered les notifications d'événement).

    Ci-dessous est un exemple simple qui montre comment il faut lire jusqu'à la read() retourne EWOULDBLOCK afin d'éviter de laisser descripteur lisibles état (je l'ai compilé et testé sur OS X, et il y a aussi la plupart du temps pas de contrôle d'erreur, mais vous devez avoir l'idée):

    /*
* FIFO example using select.
*
* $ mkfifo /tmp/fifo
* $ clang -Wall -o test ./test.c
* $ ./test &
* $ echo 'hello' > /tmp/fifo
* $ echo 'hello world' > /tmp/fifo
* $ killall test
*/
#include <sys/types.h>
#include <sys/select.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
int fd;
int n;
fd_set set;
ssize_t bytes;
size_t total_bytes;
char buf[1024];
fd = open("/tmp/fifo", O_RDWR | O_NONBLOCK);
if (fd == -1) {
perror("open");
return EXIT_FAILURE;
}
FD_ZERO(&set);
FD_SET(fd, &set);
for (;;) {
n = select(fd+1, &set, NULL, NULL, NULL);
if (!n)
continue;
if (n == -1) {
perror("select");
return EXIT_FAILURE;
}
if (FD_ISSET(fd, &set)) {
printf("Descriptor %d is ready.\n", fd);
total_bytes = 0;
for (;;) {
bytes = read(fd, buf, sizeof(buf));
if (bytes > 0) {
total_bytes += (size_t)bytes;
} else {
if (errno == EWOULDBLOCK) {
/* Done reading */
printf("done reading (%lu bytes)\n", total_bytes);
break;
} else {
perror("read");
return EXIT_FAILURE;
}
}
}
}
}
return EXIT_SUCCESS;
}

    Fondamentalement, déclenché par le niveau I/O signifie que vous avez informé tout le temps si il y a quelque chose à lire, même si vous pourriez avoir été informés de cette avant. Sur un contre, edge-triggered I/O signifie que vous obtenez averti qu'une seule fois à chaque fois que de nouvelles données arrivent et il n'importe pas si vous l'ayez lu ou pas. select() est déclenché par le niveau I/O interface.

    Espère que cela aide. Bonne Chance!

    Je pense que l'autre réponse contredit celui-ci, et c'est exact. select retourne quand un blocage read serait de retour, et read retourne 0 (signalisation EOF) si personne n'a de votre fifo ouvert pour l'écriture. Votre exemple de programme ne fait jamais cela parce qu'il a le fifo ouvert pour l'écriture elle-même.

    OriginalL'auteur