select 和poll的剖析

63 阅读 0 评论 42 点赞

我是靠谱客的博主瘦瘦大树，最近开发中收集的这篇文章主要介绍select 和poll的剖析，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

好久没剖析过网络知识了。所以这次好好的整理一下这个东西。
具体如何下整理

这是文件结构体，每个打开的文件的fd都会对应一个这样的结构体，主要是看f_op 这个主要是对文件进行操作方法的结构体

struct file {
const struct file_operations *f_op;
spinlock_t f_lock;
// 文件内部实现细节
void *private_data;
#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
struct list_head f_tfile_llink;
#endif /* #ifdef CONFIG_EPOLL */
// 其他细节....
};

f _op 结构体定义如下

struct file_operations {
// 文件提供给poll/select/epoll
// 获取文件当前状态, 以及就绪通知接口函数
unsigned int (*poll) (struct file *, struct poll_table_struct *);
// 其他方法read/write 等... ...
};

所以我们调用系统read时候实际上是调用file->f_op_read 函数。但是这个里面全是定义的函数指针，但是我们主要关注的还是这个指针poll这个主要是为了当有需要的事件到来的时候进行通知所调用的回调函数。

这个函数的定义如下

// 通常的file.f_ops.poll 方法的实现
unsigned int file_f_op_poll (struct file *filp, struct poll_table_struct *wait)
{
unsigned int mask = 0;
wait_queue_head_t * wait_queue;
//1. 根据事件掩码wait->key_和文件实现filep->private_data 取得事件掩码对应的一个或多个wait queue head
some_code();
// 2. 调用poll_wait 向获得的wait queue head 添加节点
poll_wait(filp, wait_queue, wait);
// 3. 取得当前就绪状态保存到mask
some_code();
return mask;
}

其实这个函数很简单。传进来的参数第一个是当前fd对应文件的指针，第二个参数就是下面的结构体，这个结构体中两个参数

第一个是一个函数指正第二个是key 保存当前文件的状态。

typedef struct poll_table_struct {
// 向wait_queue_head 添加回调节点(wait_queue_t)的接口函数
poll_queue_proc _qproc;
// 关注的事件掩码, 文件的实现利用此掩码将等待队列传递给_qproc
unsigned long _key;
} poll_table;
//
1. // 通用的poll_wait 函数, 文件的f_ops->poll 通常会调用此函数函数如下通过这个函数可将有事件就绪调用回调函数将他放到自己的waitqueue上。

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
if (p && p->_qproc && wait_address) {
// 调用_qproc 在wait_address 上添加节点和回调函数
// 调用 poll_table_struct 上的函数指针向wait_address添加节点, 并设置节点的func
// (如果是select或poll 则是 __pollwait, 如果是 epoll 则是 ep_ptable_queue_proc),
p->_qproc(filp, wait_address, p);
}
}

select和poll下的poll_wait 函数插入到等待队列上

// wait_queue设置函数
// poll/select 向文件wait_queue中添加节点的方法先调用__pollwait 函数将他放到等待队列上并设置为休眠然后设置唤醒函数为回调函数当有事件发生时会唤醒然后便利整个等待队列。
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
poll_table *p)
{
struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
struct poll_table_entry *entry = poll_get_entry(pwq);
if (!entry) {
return;
}
get_file(filp); //put_file() in free_poll_entry()
entry->filp = filp;
entry->wait_address = wait_address; // 等待队列头
entry->key = p->key;
// 设置回调为 pollwake
init_waitqueue_func_entry(&entry->wait, pollwake); //设置回调函数。
entry->wait.private = pwq;
// 添加到等待队列
add_wait_queue(wait_address, &entry->wait);

回调函数就是当监听的文件描述符上有状态的改变就告知它里面的key保存的就是当前掩码的值。

当文件的状态发生改变时, 文件会调用此函数，此函数通过调用wait_queue_t.func通知poll的调用者
// 其中key是文件当前的事件掩码
void __wake_up(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, void *key)
{
unsigned long flags;
spin_lock_irqsave(&q->lock, flags);
__wake_up_common(q, mode, nr_exclusive, 0, key);
spin_unlock_irqrestore(&q->lock, flags);
}

waitqueue的结构体如下

// wait_queue 头节点
typedef struct __wait_queue_head wait_queue_head_t;
struct __wait_queue_head {
spinlock_t lock;
struct list_head task_list;
};
// wait_queue 节点
typedef struct __wait_queue wait_queue_t;
struct __wait_queue {
unsigned int flags;
#define WQ_FLAG_EXCLUSIVE 0x01
void *private;
wait_queue_func_t func;
struct list_head task_list;
};
typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);

select唤醒过程的时候先判断改变key值和我自己当前的key是不是相等的如果一样的话就唤醒操作

{
struct poll_table_entry *entry;
// 取得文件对应的poll_table_entry
entry = container_of(wait, struct poll_table_entry, wait);
// 过滤不关注的事件
if (key && !((unsigned long)key & entry->key)) {
return 0;
}
// 唤醒
return __pollwake(wait, mode, sync, key);
}

唤醒程序在前面调用poll_wait 将本进程挂载到等待队列上。然后检查设备上有事件来了就唤醒该等待队列上的进程。

static int __pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
struct poll_wqueues *pwq = wait->private;
// 将调用进程 pwq->polling_task 关联到 dummy_wait
DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);
smp_wmb();
pwq->triggered = 1;// 标记为已触发
// 唤醒调用进程
return default_wake_function(&dummy_wait, mode, sync, key);
}

1. // 默认的唤醒函数,poll/select 设置的回调函数会调用此函数唤醒
2. // 直接唤醒等待队列上的线程,即将线程移到运行队列(rq)
3. int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
4. void *key)
5. {
6. // 这个函数比较复杂, 这里就不具体分析了
7. return try_to_wake_up(curr->private, mode, wake_flags);
8. }

select代码实际的话select->sys_select

asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
{
    fd_set_bits fds;
    char *bits;
    long timeout;
    int ret, size, max_fdset;

    //将用户的等待事件拷贝到内核态
    timeout = MAX_SCHEDULE_TIMEOUT;
    if (tvp) {
        time_t sec, usec;

        if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
            || (ret = __get_user(sec, &tvp->tv_sec))
            || (ret = __get_user(usec, &tvp->tv_usec)))
            goto out_nofds;

        ret = -EINVAL;
        if (sec < 0 || usec < 0)
            goto out_nofds;

        //进行单位换算
        if ((unsigned long) sec < MAX_SELECT_SECONDS) {
            timeout = ROUND_UP(usec, 1000000/HZ);
            timeout += sec * (unsigned long) HZ;
        }
    }

    ret = -EINVAL;
    if (n < 0)
        goto out_nofds;

    /* 下面代码是为了检查fd是不是大于规定的maxfd如果大于就不在对后面的放到进行呢间提供 */
    max_fdset = current->files->max_fdset;
    if (n > max_fdset)
        n = max_fdset;

    /*
     * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
     * since we used fdset we need to allocate memory in units of
     * long-words. 
     */
    ret = -ENOMEM;
    size = FDS_BYTES(n);//然后在内核中分配一个fdset的变量通过传进来的大小进行位的开辟
    //为内核的fd_set_bits申请空间并初始化
    bits = select_bits_alloc(size);

  if (!bits)
        goto out_nofds;
    fds.in      = (unsigned long *)  bits;然后获取到fds中存储不同事件位的地址
    fds.out     = (unsigned long *) (bits +   size);
    fds.ex      = (unsigned long *) (bits + 2*size);
    fds.res_in  = (unsigned long *) (bits + 3*size);
    fds.res_out = (unsigned long *) (bits + 4*size);
    fds.res_ex  = (unsigned long *) (bits + 5*size);
    //拷贝用户空间感兴趣的事件
    if ((ret = get_fd_set(n, inp, fds.in)) ||因为我们只对有数据来感兴趣所以一般只会对第二个参数进行。
        (ret = get_fd_set(n, outp, fds.out)) ||
        (ret = get_fd_set(n, exp, fds.ex)))
        goto out;
    //清空存放事件的位数组（最后有时间发生发到这个里面）
    zero_fd_set(n, fds.res_in);
    zero_fd_set(n, fds.res_out);
    zero_fd_set(n, fds.res_ex);

    //监听用户感兴趣的事件
    ret = do_select(n, &fds, &timeout);

    if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
        time_t sec = 0, usec = 0;
        if (timeout) {
            sec = timeout / HZ;
            usec = timeout % HZ;
            usec *= (1000000/HZ);
        }
        put_user(sec, &tvp->tv_sec);
        put_user(usec, &tvp->tv_usec);//返回剩余的事件
    }

    if (ret < 0)
        goto out;
    if (!ret) {
        ret = -ERESTARTNOHAND;
        if (signal_pending(current))//在这里等待可读如果time结构体为nuLL那么无限等待。或者到达所设定时间进行跳出
            goto out;
        ret = 0;
    }
    //将存放事件结果的位数组拷贝给用户参数位数组，通过修改用户传进来的位数组将事件返回给用户
    if (set_fd_set(n, inp, fds.res_in) ||
        set_fd_set(n, outp, fds.res_out) ||
        set_fd_set(n, exp, fds.res_ex))
        ret = -EFAULT;

out:
    select_bits_free(bits, size);
out_nofds:
    return ret;
}

do_select

int do_select(int n, fd_set_bits *fds, long *timeout)
{
    struct poll_wqueues table; //上面的等待队列
    poll_table *wait;
    int retval, i;
    long __timeout = *timeout;

    spin_lock(&current->files->file_lock);
    retval = max_select_fd(n, fds);//获取到轮询的次数不可能每次都循环1024 次通过最大的fdfds进行确定
    spin_unlock(&current->files->file_lock);

    if (retval < 0)
        return retval;
    n = retval;

    //设置回调函数，该回调函数将当前进程挂到等待对队中，等待队列上有可以唤醒进程的回调函数。
    poll_initwait(&table);
    wait = &table.pt;
    if (!__timeout)时间到了但是wait=NULL；
        wait = NULL;
    retval = 0;
    for (;;) {
        unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;

        set_current_state(TASK_INTERRUPTIBLE);////select是可中断的应该是休眠可以被唤醒的。

        inp = fds->in; outp = fds->out; exp = fds->ex;
        rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

        for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
            unsigned long in, out, ex, all_bits, bit = 1, mask, j;
            unsigned long res_in = 0, res_out = 0, res_ex = 0;
            struct file_operations *f_op = NULL;
            struct file *file = NULL;

            in = *inp++; out = *outp++; ex = *exp++;
            all_bits = in | out | ex;
            if (all_bits == 0) {
                i += __NFDBITS;
                continue;
            }

            for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
                if (i >= n)
                    break;
                if (!(bit & all_bits))
                    continue;
                file = fget(i);
                if (file) {
                    f_op = file->f_op;
                    mask = DEFAULT_POLLMASK;
                    if (f_op && f_op->poll)
                        //调用回调函数，为每一个fd分配一个poll_table_page，用来保存当前fd监听的事件                        
                        mask = (*f_op->poll)(file, retval ? NULL : wait);
                    fput(file);
                    //判断当前fd是否有事件发生，然后设置事件返回位数组
                    if ((mask & POLLIN_SET) && (in & bit)) {
                        res_in |= bit;
                        retval++;
                    }
                    if ((mask & POLLOUT_SET) && (out & bit)) {
                        res_out |= bit;
                        retval++;
                    }
                    if ((mask & POLLEX_SET) && (ex & bit)) {
                        res_ex |= bit;
                        retval++;
                    }
                }
                cond_resched();
            }
            //将返回事件位数组的值拷贝给传进来的参数
            if (res_in)
                *rinp = res_in;
            if (res_out)
                *routp = res_out;
            if (res_ex)
                *rexp = res_ex;
        }
        wait = NULL;
        if (retval || !__timeout || signal_pending(current))
            break;
        if(table.error) {
            retval = table.error;
            break;
        }
        __timeout = schedule_timeout(__timeout);//进程进行休眠
    }
    __set_current_state(TASK_RUNNING);
    //删除fd的poll_table_page
    poll_freewait(&table);

    *timeout = __timeout;
    return retval;
}