Named pipe + SELECT with NONBLOCK mode in Linux

Question

I'm trying to create named pipe with O_NONBLOCK mode and listen for a read event using "SELECT" method in a separate thread. There is a problem when i'm trying to close the program after some sleeping time in the main thread. I expect that when the named pipe's file descriptor is closed using close method, the select operation should immediately stop and return some value. But unfortunately, the select operation has no reaction when the file descriptor is closed and the thread which executes select method just hangs...

Any ideas how to solve it? The example code is below.

#include <pthread.h>
#include <limits.h>
#include <cctype>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <semaphore.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <exception>
#define BUFFER PIPE_BUF
#define LPVOID void *
#define BOOL int
#define TRUE 1
#define CONST const
#define CHAR char

class CPipeTest
{
    public:

    int fd;
    int nfd;
    fd_set rfd;
    pthread_t t;

    CPipeTest() {};
    ~CPipeTest() {};

    static LPVOID fnExecuteThread(LPVOID lpParam)
    {
        ((CPipeTest*)lpParam)->fnRunThread();
        return NULL;
    }

    BOOL fnRunThread()
    {
        printf("Going to listen...\r\n");
        select(nfd, &rfd, NULL, NULL, NULL);
        printf("Close listener...\r\n");
        return TRUE;
    }

    void fnInit()
    {
        CONST CHAR * name = "./test_fifo1";
        mkfifo(name, 0777);
        fd = open(name, O_NONBLOCK | O_RDONLY);
        nfd = fd + 1;
        FD_ZERO(&rfd);
        FD_SET(fd, &rfd);

        pthread_create( &t, NULL, fnExecuteThread, (LPVOID)this);

        sleep(30);
        printf("Close file descriptor - listener should be closed automatically and immediately\r\n");
        close(fd);
        printf("Descriptor closed wait for thread to to be closed\r\n");
        pthread_join(t, NULL);
        printf("Thread is closed - everything is fine\r\n");
    }

};

int main()
{
    CPipeTest pi;
    pi.fnInit();

    return 0;

}

Answer 1

Try to avoid writing to a variable in one thread, and reading from it in another.

And by avoid, I mean don't do that. :)

Every variable that fnRunThread uses should only be touched by that function unless you are synchronizing access to it.

Here you have someone doing what you did: What does select(2) do if you close(2) a file descriptor in a separate thread? and the undefined behavior is pointed out.

One good way to fix this is to have a "stop reading" command you can pass over your fifo. When the reading thread gets it, it proceeds to stop reading, then it closes the file. (note that the reading thread closes the file handle -- if the reading thread is reading from the file handle, that means it owns it. Barring some additional synchronization, once you launch the thread, you should only read from or write to variables that are owned by the thread in the thread, and should not read from or write to these variables outside of the thread).

Answer 2

There should be two file descriptors, one for reading and another for writing.

For blocking mode, the one for writing (which you will close in the initial thread) should be opened in the initial thread, after starting the "reader" thread. The one for reading should be opened in the reader thread. For non-blocking mode, it may be done in the same thread, if you first open for reading, then for writing (or ENXIO will be returned for opening writer with no reader).

When you close the writing side, the reading side will receive notification with select. (If there would be a real data exchange, the following read would read zero bytes, that's how you detect EOF).

If you switch to anonymous pipes, you'll get a pair of descriptors from the pipe call automatically.

Answer 3

The problem is a FIFO (a special type of file) has to be open at both ends before you can do anything with it. It doesn't make sense you close the same end and expect the other thread to react.

The following code should do what you want:

    ....
    nfd = fd + 1;
    FD_ZERO(&rfd);
    FD_SET(fd, &rfd);

    int write_fd = open(name, O_WRONLY);   // open the other end
    pthread_create( &t, NULL, fnExecuteThread, (LPVOID)this);

    sleep(30);
    printf("Close file descriptor - listener should be closed automatically and immediately\r\n");
    close(write_fd);                       // close the other end
    ....