Socket层实现系列 — 睡眠驱动的同步等待

主要内容：Socket的同步等待机制，connect和accept等待的实现。

内核版本：3.15.2

我的博客：http://blog.csdn.net/zhangskd

 

概述

 

socket上定义了几个IO事件：状态改变事件、有数据可读事件、有发送缓存可写事件、有IO错误事件。

对于这些事件，socket中分别定义了相应的事件处理函数，也称回调函数。

 

Socket I/O事件的处理过程中，要使用到sock上的两个队列：等待队列和异步通知队列，这两个队列中

都保存着等待该Socket I/O事件的进程。

 

Q：为什么要使用两个队列，等待队列和异步通知队列有什么区别呢？

A：等待队列上的进程会睡眠，直到Socket I/O事件的发生，然后在事件处理函数中被唤醒。

异步通知队列上的进程则不需要睡眠，Socket I/O事件发时，事件处理函数会给它们发送到信号，

这些进程事先注册的信号处理函数就能够被执行。

 

等待队列

 

Socket层使用等待队列来进行阻塞等待，在等待期间，阻塞在此socket上的进程会睡眠。

struct sock {    ...    struct socket_wq __rcu *sk_wq; /* socket的等待队列和异步通知队列 */    ...}struct socket_wq {    /* Note: wait MUST be first field of socket_wq */    wait_queue_head_t wait; /* 等待队列头 */    struct fasync_struct *fasync_list; /* 异步通知队列 */    struct rcu_head *rcu;};

 

(1)  socket的等待队列头

struct __wait_queue_head {    spinlock_t lock;    struct list_head task_list;};typedef struct __wait_queue_head wait_queue_head_t;

 

(2) 进程的等待任务

struct __wait_queue {    unsigned int flags;#define WQ_FLAG_EXCLUSIVE 0x01    void *private; /* 指向当前的进程控制块 */    wait_queue_func_t func; /* 唤醒函数 */    struct list_head task_list; /* 用于链接入等待队列 */};typedef struct __wait_queue wait_queue_t;typedef int (*wait_queue_func_t) (wait_queue_t *wait, unsigned mode, int flags, void *key);int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key);

 

(3) 初始化等待任务

#define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)#define DEFINE_WAIT_FUNC(name, function)    \    wait_queue_t name = {    \        .private = current,    \        .func = function,    \        .task_list = LIST_HEAD_INIT((name).task_list),    \    }int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key){    int ret = default_wake_function(wait, mode, sync, key); /* 默认的唤醒函数 */    if (ret)        list_del_init(&wait->task_list); /* 从等待队列中删除 */    return ret;}int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags, void *key){    return try_to_wake_up(curr->private, mode, wake_flags);}

try_to_wake_up()通过把进程的状态设置为TASK_RUNNING，并把进程插入CPU运行队列，来唤醒睡眠的进程。

 

(4) 把等待任务插入到等待队列中

获取sock的等待队列。

static inline wait_queue_head_t *sk_sleep(struct sock *sk){    BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0);    return &rcu_dereference_raw(sk->sk_wq)->wait;}

把等待任务加入到等待队列中，同时设置当前进程的状态，TASK_INTERRUPTIBLE或TASK_UNINTERRUPTIBLE。

void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state){    unsigned long flags;    wait->flags &= ~WQ_FLAG_EXCLUSIVE; /* 可以同时唤醒多个等待进程 */    spin_lock_irqsave(&q->lock, flags);    if (list_empty(&wait->task_list))        __add_wait_queue(q, wait); /* 把等待任务加入到等待队列的头部，会最先被唤醒 */    set_current_state(state); /* 设置进程的状态 */    spin_unlock_irqrestore(&q->lock, flags);}

 

prepare_to_wait()和prepare_to_wait_exclusive()都是用来把等待任务加入到等待队列中，不同之处在于

使用prepare_to_wait_exclusive()时，会在等待任务中添加WQ_FLAG_EXCLUSIVE标志，表示一次只能

唤醒一个等待任务，目的是为了避免惊群现象。

void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state){    unsigned long flags;    /* 这个标志表示一次只唤醒一个等待任务，避免惊群现象 */    wait->flags |= WQ_FLAG_EXCLUSIVE;    spin_lock_irqsave(&q->lock, flags);    if (list_empty(&wait->task_list))        __add_wait_queue_tail(q, wait); /* 把此等待任务加入到等待队列尾部 */    set_current_state(state); /* 设置当前进程的状态 */    spin_unlock_irqrestore(&q->lock, flags);}static inline void __add_wait_queue_tail(wait_queue_head_t *head, wait_queue_t *new){    list_add_tail(&new->task_list, &head->task_list);}#define set_current_state(state_value)    \    set_mb(current->state, (state_value))

 

(5) 删除等待任务

从等待队列中删除等待任务，同时把等待进程的状态置为可运行状态，即TASK_RUNNING。

/** * finish_wait - clean up after waiting in a queue * @q: waitqueue waited on，等待队列头 * @wait: wait descriptor，等待任务 * * Sets current thread back to running state and removes the wait  * descriptor from the given waitqueue if still queued. */void finish_wait(wait_queue_head_t *q, wait_queue_t *wait){    unsigned long flags;    __set_current_state(TASK_RUNNING);    if (! list_empty_careful(&wait->task_list)) {        spin_lock_irqsave(&q->lock, flags);        list_del_init(&wait->task_list); /* 从等待队列中删除 */        spin_unlock_irqrestore(&q->lock, flags);    }}

 

connect等待

 

(1) 睡眠

connect()的超时时间为sk->sk_sndtimeo，在sock_init_data()中初始化为MAX_SCHEDULE_TIMEOUT，

表示无限等待，可以通过SO_SNDTIMEO选项来修改。

static long inet_wait_for_connect(struct sock *sk, long timeo, int writebias){    DEFINE_WAIT(wait);  /* 初始化等待任务 */    /* 把等待任务加入到socket的等待队列头部，把进程的状态设为TASK_INTERRUPTIBLE */    prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);    sk->sk_write_pending += writebias;    /* Basic assumption: if someone sets sk->sk_err, he _must_ change state of the socket     * from TCP_SYN_*. Connect() does not allow to get error notifications without closing     * the socket.     */    /* 完成三次握手后，状态就会变为TCP_ESTABLISHED，从而退出循环 */    while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {        release_sock(sk); /* 等下要睡觉了，先释放锁 */        /* 进入睡眠，直到超时或收到信号，或者被I/O事件处理函数唤醒。         * 1. 如果是收到信号退出的，timeo为剩余的jiffies。         * 2. 如果使用了SO_SNDTIMEO选项，超时退出后，timeo为0。         * 3. 如果没有使用SO_SNDTIMEO选项，timeo为无穷大，即MAX_SCHEDULE_TIMEOUT，         *      那么返回值也是这个，而超时时间不定。为了无限阻塞，需要上面的while循环。         */        timeo = schedule_timeout(timeo);                 lock_sock(sk); /* 被唤醒后重新上锁 */        /* 如果进程有待处理的信号，或者睡眠超时了，退出循环，之后会返回错误码 */        if (signal_pending(current) || !timeo)            break;            /* 继续睡眠吧 */        prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);    }    /* 等待结束时，把等待进程从等待队列中删除，把当前进程的状态设为TASK_RUNNING */    finish_wait(sk_sleep(sk), &wait);    sk->sk_write_pending -= writebias;    return timeo;} 

 

(2) 唤醒

三次握手中，当客户端收到SYNACK、发出ACK后，连接就成功建立了。

此时连接的状态从TCP_SYN_SENT或TCP_SYN_RECV变为TCP_ESTABLISHED，sock的状态发生变化，

会调用sock_def_wakeup()来处理连接状态变化事件，唤醒进程，connect()就能成功返回了。

sock_def_wakeup()的函数调用路径如下：

tcp_v4_rcv

tcp_v4_do_rcv

tcp_rcv_state_process

tcp_rcv_synsent_state_process

tcp_finish_connect

sock_def_wakeup

wake_up_interruptible_all

__wake_up

__wake_up_common

void tcp_finish_connect(struct sock *sk, struct sk_buff *skb){    ...    tcp_set_state(sk, TCP_ESTABLISHED); /* 在这里设置为连接已建立的状态 */    ...    if (! sock_flag(sk, SOCK_DEAD)) {        sk->sk_state_change(sk); /* 指向sock_def_wakeup，会唤醒调用connect()的进程，完成连接的建立 */        sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT); /* 如果使用了异步通知，则发送SIGIO通知进程可写 */    }}

 

accept等待

 

(1) 睡眠

accept()超时时间为sk->sk_rcvtimeo，在sock_init_data()中初始化为MAX_SCHEDULE_TIMEOUT，表示无限等待。

/* Wait for an incoming connection, avoid race conditions. * This must be called with the socket locked. */static int inet_csk_wait_for_connect(struct sock *sk, long timeo){    struct inet_connection_sock *icsk = inet_csk(sk);    DEFINE_WAIT(wait); /* 初始化等待任务 */    int err;    for (; ;) {        /* 把等待任务加入到socket的等待队列中，把进程状态设置为TASK_INTERRUPTIBLE */        prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);        release_sock(sk); /* 等下可能要睡觉了，先释放 */        if (reqsk_queue_empty(&icsk->icsk_accept_queue)) /* 如果全连接队列为空 */            timeo = schedule_timeout(timeo); /* 进入睡眠直到超时或收到信号，或被IO事件处理函数唤醒 */                lock_sock(sk); /* 醒来后重新上锁 */        err = 0;        /* 全连接队列不为空时，说明有新的连接建立了，成功返回 */        if (! reqsk_queue_empty(&icsk->icsk_accept_queue))             break;        err = -EINVAL;        if (sk->sk_state != TCP_LISTEN) /* 如果sock不处于监听状态了，退出，返回错误码 */            break;        err = sock_intr_errno(timeo);        /* 如果进程有待处理的信号，退出，返回错误码。         * 因为timeo默认为MAX_SCHEDULE_TIMEOUT，所以err默认为-ERESTARTSYS。         * 接下来会重新调用此函数，所以accept()依然阻塞。         */        if (signal_pending(current))            break;         err = -EAGAIN;        if (! timeo) /* 如果等待超时，即超过用户设置的sk->sk_rcvtimeo，退出 */            break;    }    /* 从等待队列中删除等待任务，把等待进程的状态设为TASK_RUNNING */    finish_wait(sk_sleep(sk), &wait);    return err;}

 

(2) 唤醒

三次握手中，当服务器端接收到ACK完成连接建立的时候，会把新的连接链入全连接队列中，

然后唤醒监听socket上的等待进程，accept()就能成功返回了。

三次握手时，当收到客户端的ACK后，经过如下调用：

tcp_v4_rcv

tcp_v4_do_rcv

tcp_child_process

sock_def_readable

wake_up_interruptible_sync_poll

__wake_up_sync_key

__wake_up_common

最终调用我们给等待任务注册的唤醒函数。

 

我们来看下accept()是如何避免惊群现象的。

static void __wake_up_common(wait_queue_head_t *q, unsigned int mode, int nr_exclusive,                              int wake_flags, void *key){    wait_queue_t *curr, *next;    list_for_each_entry_safe(curr, next, &q->task_list, task_list) {        unsigned flags = curr->flags;        if (curr->func(curr, mode, wake_flags, key) && (flags & WQ_FLAG_EXCLUSIVE)            !--nr_exclusive)            break;    }}

初始化等待任务时，flags |= WQ_FLAG_EXCLUSIVE。传入的nr_exclusive为1，表示只允许唤醒一个等待任务。

所以这里只会唤醒一个等待的进程，不会导致惊群现象。