poll() 的用法

需求

在某个xxxservice 里要持续读 /dev/sample_dev 节点。也就是在while循环里面，先poll是否可读，如果可读的话就去调用read，如果不可读的话就继续调用poll，如此循环。

但是，如果与 /dev/sample_dev 节点相关的设备已不再提供数据了（比如说设备拔掉）。那么每次调用poll会timeout，如此循环，空耗CPU资源。

此时底层驱动可以给应用层返回特定的值告诉断开，xxxservice可以根据这个返回值break出while循环，这样就不会一直在while循环。

在实现这个需求的过程中，学习到了poll的相关用法，现总结如下。

---

poll的用法

在Ubuntu终端输入#man poll 就可以查看poll的用法了。

POLL(2)                                              Linux Programmer's Manual                                              POLL(2)



NAME
       poll, ppoll - wait for some event on a file descriptor

SYNOPSIS
       #include <poll.h>

       int poll(struct pollfd *fds, nfds_t nfds, int timeout);

       #define _GNU_SOURCE         /* See feature_test_macros(7) */
       #include <poll.h>

       int ppoll(struct pollfd *fds, nfds_t nfds,
               const struct timespec *timeout_ts, const sigset_t *sigmask);

DESCRIPTION
       poll() performs a similar task to select(2): it waits for one of a set of file descriptors to become ready to perform I/O.

       The set of file descriptors to be monitored is specified in the fds argument, which is an array of structures of the follow‐
       ing form:

           struct pollfd {
               int   fd;         /* file descriptor */
               short events;     /* requested events */
               short revents;    /* returned events */
           };

       The caller should specify the number of items in the fds array in nfds.

       The field fd contains a file descriptor for an open file.  If this field is negative, then the corresponding events field is
       ignored  and  the  revents field returns zero.  (This provides an easy way of ignoring a file descriptor for a single poll()
       call: simply negate the fd field.)

       The field events is an input parameter, a bit mask specifying the events the application  is  interested  in  for  the  file
       descriptor fd.  If this field is specified as zero, then all events are ignored for fd and revents returns zero.

       The field revents is an output parameter, filled by the kernel with the events that actually occurred.  The bits returned in
       revents can include any of those specified in events, or one of the values POLLERR, POLLHUP, or POLLNVAL.  (These three bits
       are meaningless in the events field, and will be set in the revents field whenever the corresponding condition is true.)

       If none of the events requested (and no error) has occurred for any of the file descriptors, then poll() blocks until one of
       the events occurs.

       The timeout argument specifies the number of milliseconds that poll() should block waiting for a file descriptor  to  become
       ready.   This interval will be rounded up to the system clock granularity, and kernel scheduling delays mean that the block‐
       ing interval may overrun by a small amount.  Specifying a negative value in timeout means an infinite timeout.  Specifying a
       timeout of zero causes poll() to return immediately, even if no file descriptors are ready.

       The bits that may be set/returned in events and revents are defined in <poll.h>:

              POLLIN There is data to read.

              POLLPRI
                     There  is  urgent data to read (e.g., out-of-band data on TCP socket; pseudoterminal master in packet mode has
                     seen state change in slave).

              POLLOUT
                     Writing now will not block.

              POLLRDHUP (since Linux 2.6.17)
                     Stream socket peer closed connection, or shut down writing half of connection.  The _GNU_SOURCE  feature  test
                     macro must be defined (before including any header files) in order to obtain this definition.

              POLLERR
                     Error condition (output only).

              POLLHUP
                     Hang up (output only).

              POLLNVAL
                     Invalid request: fd not open (output only).

       When  compiling  with _XOPEN_SOURCE defined, one also has the following, which convey no further information beyond the bits
       listed above:

              POLLRDNORM
                     Equivalent to POLLIN.

              POLLRDBAND
                     Priority band data can be read (generally unused on Linux).

              POLLWRNORM
                     Equivalent to POLLOUT.

              POLLWRBAND
                     Priority data may be written.

       Linux also knows about, but does not use POLLMSG.

   ppoll()
       The relationship between poll() and ppoll() is analogous to the relationship between select(2)  and  pselect(2):  like  pse‐
       lect(2),  ppoll()  allows  an  application  to safely wait until either a file descriptor becomes ready or until a signal is
       caught.

       Other than the difference in the precision of the timeout argument, the following ppoll() call:

           ready = ppoll(&fds, nfds, timeout_ts, &sigmask);

       is equivalent to atomically executing the following calls:

           sigset_t origmask;
           int timeout;

           timeout = (timeout_ts == NULL) ? -1 :
                     (timeout_ts.tv_sec * 1000 + timeout_ts.tv_nsec / 1000000);
           sigprocmask(SIG_SETMASK, &sigmask, &origmask);
           ready = poll(&fds, nfds, timeout);
           sigprocmask(SIG_SETMASK, &origmask, NULL);

       See the description of pselect(2) for an explanation of why ppoll() is necessary.

       If the sigmask argument is specified as NULL, then no signal mask manipulation is performed (and thus ppoll()  differs  from
       poll() only in the precision of the timeout argument).

       The  timeout_ts argument specifies an upper limit on the amount of time that ppoll() will block.  This argument is a pointer
       to a structure of the following form:

           struct timespec {
               long    tv_sec;         /* seconds */
               long    tv_nsec;        /* nanoseconds */
           };

       If timeout_ts is specified as NULL, then ppoll() can block indefinitely.

RETURN VALUE
       On success, a positive number is returned; this is the number of structures which have  nonzero  revents  fields  (in  other
       words,  those  descriptors  with  events  or  errors  reported).  A value of 0 indicates that the call timed out and no file
       descriptors were ready.  On error, -1 is returned, and errno is set appropriately.

ERRORS
       EFAULT The array given as argument was not contained in the calling program's address space.

       EINTR  A signal occurred before any requested event; see signal(7).

       EINVAL The nfds value exceeds the RLIMIT_NOFILE value.

       ENOMEM There was no space to allocate file descriptor tables.

VERSIONS
       The poll() system call was introduced in Linux 2.1.23.  On older kernels that lack this system call, the glibc (and the  old
       Linux libc) poll() wrapper function provides emulation using select(2).

       The ppoll() system call was added to Linux in kernel 2.6.16.  The ppoll() library call was added in glibc 2.4.

CONFORMING TO
       poll() conforms to POSIX.1-2001.  ppoll() is Linux-specific.

NOTES
       Some  implementations  define  the nonstandard constant INFTIM with the value -1 for use as a timeout for poll().  This con‐
       stant is not provided in glibc.

       For a discussion of what may happen if a file descriptor being  monitored  by  poll()  is  closed  in  another  thread,  see
       select(2).

   Linux notes
       The  Linux ppoll() system call modifies its timeout_ts argument.  However, the glibc wrapper function hides this behavior by
       using a local variable for the timeout argument that is passed to the system call.  Thus, the glibc  ppoll()  function  does
       not modify its timeout_ts argument.

BUGS
       See the discussion of spurious readiness notifications under the BUGS section of select(2).

SEE ALSO
       restart_syscall(2), select(2), select_tut(2), time(7)

COLOPHON
       This  page  is  part  of  release  3.54 of the Linux man-pages project.  A description of the project, and information about
       reporting bugs, can be found at http://www.kernel.org/doc/man-pages/.



Linux                                                        2013-09-04                                                     POLL(2)

该函数的声明如下：

#include <poll.h>

struct pollfd {
    int   fd;         /* file descriptor */
    short events;     /* requested events */
    short revents;    /* returned events */
};

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

---

参数struct pollfd *fds

poll() 就是等待一个文件描述集合变为可读或可写。该文件描述集合由struct pollfd 来表示。

• 成员fd为一个已open的文件句柄，即想要侦听的文件；
• 成员events是输入的参数，需要自己指定想要侦听fd的哪个事件，比如说常见的POLLIN| POLLRDNORM 来表示侦听可读；
• 成员revents是输出的参数，由内核来填充事件。当poll()函数返回正数时，此时也要判断成员revents的事件以此来做下一步的动作。
  POLLERR/ POLLHUP/ POLLNVAL 这三个事件只会在 revents 中出现，不会在events中出现。

---

参数nfds_t nfds

nfds指定所要侦听的文件个数。

---

参数int timeout

timeout指定poll()需要block多少ms，如果发生timeout，那么poll()的返回值为0。

---

返回值

poll()函数有三种返回值：

• 返回值>0，表示已侦听到events指定的事件或者出错返回给revents；
• 返回值=0，表示timeout时间到或者出错返回给revents；
• 返回值<0，也就是-1，表示出错。

所以说，当返回值>=0的时候，我们有必要去查看一下revents里面的事件，看看当前的情况。

---

poll 的事件定义

uapi/asm-generic/poll.h


#ifndef2 __ASM_GENERIC_POLL_H
#define __ASM_GENERIC_POLL_H

/* These are specified by iBCS2 */
#define POLLIN      0x0001
#define POLLPRI     0x0002
#define POLLOUT     0x0004
#define POLLERR     0x0008
#define POLLHUP     0x0010
#define POLLNVAL    0x0020

/* The rest seem to be more-or-less nonstandard. Check them! */
#define POLLRDNORM  0x0040
#define POLLRDBAND  0x0080
#ifndef POLLWRNORM
#define POLLWRNORM  0x0100
#endif
#ifndef POLLWRBAND
#define POLLWRBAND  0x0200
#endif
#ifndef POLLMSG
#define POLLMSG     0x0400
#endif
#ifndef POLLREMOVE
#define POLLREMOVE  0x1000
#endif
#ifndef POLLRDHUP
#define POLLRDHUP       0x2000
#endif

#define POLLFREE    0x4000  /* currently only for epoll */

#define POLL_BUSY_LOOP  0x8000

struct pollfd {
    int fd;
    short events;
    short revents;
};

#endif  /* __ASM_GENERIC_POLL_H */

---

驱动返回特定的值

还是以sample_dev读写为例，详见：http://blog.csdn.net/encourage2011/article/details/52940087。假设我设备拔掉的时候，会调用unbind，此时我们去设置disconnected成员，用来标记设备拔掉。如下：

static int sample_unbind()
{
    sample_dev->disconnected = 1;
}

static int sample_bind()
{
    sample_dev->disconnected = 0;
}

接下来驱动的所有操作都要围绕 sample_dev->disconnected 来做。当调用read/write，如果已经disconnected，那么需要直接返回-ENODEV，告诉应用层表示设备断开了。如果是poll，那么需要返回 POLLERR | POLLHUP 来告诉应用层表示设备断开。修改之后的函数如下：

static int sample_write(struct file * file, const char __user * buf, size_t count, loff_t *f_pos)
{
    int ret = count;
    if (sample_dev->disconnected)
        return -ENODEV;
    sample_dbg("[sample] %s line = %d: count = %d, f_pos = %d\n", __func__, __LINE__, count, *f_pos);

    if (copy_from_user(sample_dev->buf+*f_pos, buf, count)) {
        sample_dbg("[sample] copy from user error\n");
        ret = -EFAULT;
    }
    sample_dbg("[sample] write:buf = %s\n", sample_dev->buf+*f_pos);

    // 写完之后可以读，但不能写，唤醒读
    sample_dev->completed_in_req = 1;
    sample_dev->completed_out_req = 0;
    wake_up_interruptible(&sample_dev->read_queue);
    return ret;
}

static int sample_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    int ret = count;
    if (sample_dev->disconnected)
        return -ENODEV;
    sample_dbg("[sample] %s line = %d: count = %d, f_pos = %d\n", __func__, __LINE__, count, *f_pos);
    sample_dbg("[sample] read:buf = %s\n", sample_dev->buf);
    if (copy_to_user(buf, sample_dev->buf, count)) {
        ret = -EFAULT;
        sample_dbg("[sample] copy to user error\n");
    }

    // 读完之后可以写，但不能读，唤醒写
    sample_dev->completed_in_req = 0;
    sample_dev->completed_out_req = 1;
    wake_up_interruptible(&sample_dev->write_queue);

    return ret;
}

long sample_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    if (sample_dev->disconnected)
        return -ENODEV;

    switch(cmd) {
        case IOC_SAMPLE_CMD0:
            break;

        case IOC_SAMPLE_CMD1:
            break;

        default:
            break;
    }
    return 0;
}

static unsigned int sample_poll(struct file *fd, poll_table *wait)
{
    unsigned int    ret = 0;
    sample_dbg("[sample] %s line = %d\n", __func__, __LINE__);
    //if (sample_dev->disconnected)
    //  return -ENODEV;
    if (sample_dev->disconnected) {
        ret = POLLERR | POLLHUP;
        return ret; 
    }

    poll_wait(fd, &sample_dev->read_queue, wait);
    poll_wait(fd, &sample_dev->write_queue, wait);

    if(sample_dev->completed_out_req)
        ret |= POLLOUT | POLLWRNORM;

    if (sample_dev->completed_in_req)
        ret |= POLLIN | POLLRDNORM;

    return ret;
}

注意，这里的poll无法直接返回 –ENODEV，测试发现，当在驱动中人为设置poll每次返回-ENODEV，应用层都无法读到这个返回值，每次都是timeout，返回值为0。具体原因还不清楚。

---

应用层测试程序

使用poll()的时候，必须检查 Events.revents 的值。不能单纯的判断返回值。

// sample_test.c

#define FILE_PATH "/dev/sample_dev"

int main(int argc, char **argv)
{
    int ret = 0;
    int fd;
    char *wr_buf = "aaaaa";
    char rd_buf[10];
    struct pollfd Events;
    int revents;

    memset(&Events, 0 ,sizeof(Events));

    fd = open(FILE_PATH, O_RDWR | O_NDELAY);
    if (fd < 0)
    {
        printf("[sample_test] open %s failed!!!!\n", FILE_PATH);
        return -1;
    }

    Events.fd = fd;
    Events.events = POLLOUT | POLLWRNORM;
    ret = poll(&Events, 1, 1000);
    if (ret < 0) {
        printf("[sample_test] write POLL ERROR");
    } else if (ret == 0) {
        printf("[sample_test] write POLL timeout");
    } else {
        ret = write(fd, wr_buf, sizeof(wr_buf));
    }

    Events.fd = fd;
    Events.events = POLLIN | POLLRDNORM;
    while (1) {
        ret = poll(&Events, 1, 1000);
        if (ret < 0) {
            printf("[sample_test] read POLL ERROR, break\n");
            break;
        } else if (ret == 0) {
            printf("[sample_test] read POLL timeout, continue\n");
            continue;
        } else {
            revents = Events.revents;
            if ((revents == POLLIN) || (revents == POLLRDNORM)) {
                ret = read(fd, rd_buf, 4);
                if (ret < 0) {
                    printf("[sample_test] read error, error:%s, errno = %d\n", strerr(errno), errno);
                    if (errno == ENODEV) {
                        printf("[sample_test] device disconnect, break\n");
                        break;
                    }
                    else {
                        break;  
                    }
                }
            }
            else if ((revents == POLLERR) || (revents == POLLHUP)) {
                printf("[sample_test] device error, break\n");
                break;
            }
        }
    }
    close(fd);
    return ret;
}