Non-blocage de lire sur un tuyau

Peut-on faire de la non-blocage I/O sur un tuyau? fcntl ne parvient pas à définir O_NONBLOCK. Page 918 Linux, l'Interface de Programmation comprend un tableau, " la Sémantique de la lecture de n octets à partir de tube ou FIFO (p)'. Ce tableau présente le comportement des tubes et les FIFO avec une colonne intitulée O_NONBLOCK est-il activé? Cela signifie que vous pouvez définir l'attribut O_NONBLOCK sur un tuyau. Est-ce correct? Le code suivant ne parvient pas à définir le drapeau, fcntl(2) ne signale pas une erreur, même si.

#include <fcntl.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define SLEEP 1

int
main(int argc, char *argv[]) {
    pid_t childPid;
    int pfd[2];
    int nread, flags;
    int c = 'a';    

    setbuf(stdout, NULL);

    if (pipe(pfd) == -1) {
        printf("error: pipe");
        exit(EXIT_FAILURE);
    }

    switch (childPid = fork()) {
    case -1:
        printf("error: fork");
        exit(EXIT_FAILURE);
    case 0:         /* child */
        if (close(pfd[0]) == -1) {
            printf("child: close pfd read");
            exit(EXIT_FAILURE);
        }
        sleep(SLEEP);
        _exit(EXIT_SUCCESS);
    default:
        break;
                /* parent falls through */
    }
    if (close(pfd[1]) == -1) {
        printf("parent: close pipe write");
        exit(EXIT_FAILURE);
    }

    flags = fcntl(pfd[0], F_GETFD);
    flags |= O_NONBLOCK;
    if (fcntl(pfd[0], F_SETFD, flags))
        perror("fcntl");

    /* verify flags set correctly */
    flags = fcntl(pfd[0], F_GETFD);
    if (!(flags & O_NONBLOCK))  {
        printf("failed to set O_NONBLOCK\n");
        exit(EXIT_FAILURE);
    }

    wait(NULL);
    exit(EXIT_SUCCESS);
}

Il ressemble à un bug dans le F_GETFD opération. J'ai confirmé que cela n'en fait définir le descripteur de non-blocage et de l'exploitation n'est pas en bloc, mais F_GETFD renvoie toujours zéro.

OriginalL'auteur Tobin | 2016-04-17

Il n'y a rien de spécial à pipe et O_NONBLOCK. L'exemple suivant fonctionne comme prévu. Je n'ai pas vérifié tous les retval de tous les appeler pour faire un exemple un peu plus lisible. Une application du monde réel doit effectuer les vérifications.

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>

int main()
{
    int fds[2];
    pid_t pid;
    char buf[100];

    pipe(fds);

    pid = fork();

    if ( pid )
    {
        while (1 )
        {
            memcpy( buf, "abcdefghi#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
int main()
{
int fds[2];
pid_t pid;
char buf[100];
pipe(fds);
pid = fork();
if ( pid )
{
while (1 )
{
memcpy( buf, "abcdefghi\0",10);
write( fds[1], buf, 10);
sleep(2);
}
}
else
{
int retval = fcntl( fds[0], F_SETFL, fcntl(fds[0], F_GETFL) | O_NONBLOCK);
printf("Ret from fcntl: %d\n", retval);
while (1)
{
ssize_t r=read( fds[0], buf, 10 );
printf("read: %d\n", r);
if ( r > 0 )
{
printf("Buffer: %s\n", buf);
}
else
{
printf("Read nothing\n");
perror("Error was");
sleep(1);
}
}
}
}
",10);
            write( fds[1], buf, 10);
            sleep(2);
        }
    }
    else
    {
        int retval = fcntl( fds[0], F_SETFL, fcntl(fds[0], F_GETFL) | O_NONBLOCK);
        printf("Ret from fcntl: %d\n", retval);
        while (1)
        {
            ssize_t r=read( fds[0], buf, 10 );
            printf("read: %d\n", r);

            if ( r > 0 )
            {
                printf("Buffer: %s\n", buf);
            }
            else
            {
                printf("Read nothing\n");
                perror("Error was");
                sleep(1);
            }
        }
    }
}

Après avoir écrit mon exemple, j'ai inspecter votre code et trouvé:

flags = fcntl(pfd[0], F_GETFD);
flags |= O_NONBLOCK;
if (fcntl(pfd[0], F_SETFD, flags))

S'il vous plaît changer F_SETFD à F_SETFL et également à l'opération. Vous ne voudriez pas changer le file descriptor flags mais la file descriptor status flags 🙂

De man 3 fcntl:

Descripteur de fichier drapeaux
Les commandes suivantes permettent de manipuler les indicateurs associés à un fichier
descripteur. Actuellement, un seul indicateur est défini: FD_CLOEXEC, l'
close-on-exec drapeau. Si le bit FD_CLOEXEC est 0, le descripteur de fichier
restera ouvert même au travers d'un execve(2), sinon il sera fermé.

Fichier indicateurs d'état
Chaque description du fichier ouvert a certains associés indicateurs d'état, ini‐
tialized par open(2) et éventuellement modifiées par fcntl(). Dupliqué le fichier
descripteurs (avec dup(2), fcntl(F_DUPFD), fork(2), etc.) reportez-vous à
de la même ouvrir le fichier de description, et ainsi partager le même fichier d'état
drapeaux.

F_SETFL (int)
Définir le fichier de drapeaux d'état à la valeur spécifiée par arg. Fichier
mode d'accès (O_RDONLY, O_WRONLY, O_RDWR) et la création du fichier de drapeaux
(c'est à dire, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC) dans les arg sont ignorés.
Sous Linux, cette commande peut ne changer que la O_APPEND, O_ASYNC,
O_DIRECT, O_NOATIME, et O_NONBLOCK drapeaux. Il n'est pas possible
pour modifier le O_DSYNC et O_SYNC drapeaux; voyez des BUGS, ci-dessous.

Bonne prise Klaus, j'avais le sentiment que c'était quelque chose de stupide, j'étais en train de faire. Je vous remercie pour votre temps.

OriginalL'auteur Klaus

Vous devez vous connecter pour publier un commentaire.