Linux网络协议栈 -- socket listen监听

一、sys_listen
 

对面向连接的协议，在调用 bind(2)后，进一步调用 listen(2)，让套接字进入监听状态： 

int listen(int sockfd, int backlog);
 
backlog 表示新建连接请求时，最大的未处理的积压请求数。 
 
这里说到让套接字进入某种状态，也就是说，涉及到套接字的状态变迁，前面 create 和bind 时，也遇到过相应的代码。 
 
sock和 sk 都有相应的状态字段，先来看 sock 的： 
typedef enum { 
        SS_FREE = 0,                        /*  套接字未分配                */ 
        SS_UNCONNECTED,                        /*  套接字未连接        */ 
        SS_CONNECTING,                        /*  套接字正在处理连接        */ 
        SS_CONNECTED,                        /*  套接字已连接                */ 
        SS_DISCONNECTING                /*  套接字正在处理关闭连接 */ } socket_state;
 
在创建套接字时，被初始化为 SS_UNCONNECTED。 
 
对于面向连接模式的SOCK_TREAM来讲，这样描述状态显然是不够的。 这样， 在sk中， 使用sk_state维护了一个有限状态机来描述套接字的状态： 
enum { 
  TCP_ESTABLISHED = 1, 
  TCP_SYN_SENT, 
  TCP_SYN_RECV, 
  TCP_FIN_WAIT1, 
  TCP_FIN_WAIT2, 
  TCP_TIME_WAIT, 
  TCP_CLOSE, 
  TCP_CLOSE_WAIT, 
  TCP_LAST_ACK, 
  TCP_LISTEN, 
  TCP_CLOSING,         /* now a valid state */ 
 
  TCP_MAX_STATES /* Leave at the end! */ 
};
 
还有一个相应的用来进行状态位运算的枚举结构： 
enum { 
  TCPF_ESTABLISHED = (1 << 1), 
  TCPF_SYN_SENT  = (1 << 2), 
  TCPF_SYN_RECV  = (1 << 3), 
  TCPF_FIN_WAIT1 = (1 << 4), 
  TCPF_FIN_WAIT2 = (1 << 5), 
  TCPF_TIME_WAIT = (1 << 6), 
  TCPF_CLOSE     = (1 << 7), 
  TCPF_CLOSE_WAIT = (1 << 8), 
  TCPF_LAST_ACK  = (1 << 9), 
  TCPF_LISTEN    = (1 << 10), 
  TCPF_CLOSING   = (1 << 11)  
};
 
值得一提的是，sk 的状态不等于 TCP的状态，虽然 sk 是面向协议栈，但它的状态并不能同 TCP状态一一直接划等号。虽然这些状态值都用 TCP-XXX 来表式，但是只是因为 TCP协议状态非常复杂。sk 结构只是利用它的一个子集来抽像描述而已。 
 
同样地，操作码 SYS_LISTEN的任务会落到 sys_listen()函数身上： 

/* Maximum queue length specifiable by listen.  */    

#define SOMAXCONN        128 

int sysctl_somaxconn = SOMAXCONN; 
 
asmlinkage long sys_listen(int fd, int backlog) 
{ 
        struct socket *sock; 
        int err; 
         
        if ((sock = sockfd_lookup(fd, &err)) != NULL) { 
                if ((unsigned) backlog > sysctl_somaxconn) 
                        backlog = sysctl_somaxconn; 
 
                err = security_socket_listen(sock, backlog); 
                if (err) { 
                        sockfd_put(sock); 
                        return err; 
                } 
 
                err=sock->ops->listen(sock, backlog); 
                sockfd_put(sock); 
        } 
        return err; 
}
 
同样地，函数会最终转向协议簇的 listen 函数，也就是 inet_listen()： 
 
/* 
*        Move a socket into listening state. 
*/ 
int inet_listen(struct socket *sock, int backlog) 
{ 
        struct sock *sk = sock->sk; 
        unsigned char old_state; 
        int err; 
 
        lock_sock(sk); 
 
        err = -EINVAL; 
        /* 在 listen 之前，sock 必须为未连接状态，且只有 SOCK_STREAM 类型，才有 listen(2)*/ 
        if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM) 
                goto out; 
 
        /*  临时保存状态机状态 */ 
        old_state = sk->sk_state;         /*  只有状态机处于 TCP_CLOSE  或者是 TCP_LISTEN  这两种状态时，才可能对其调用listen(2)  ，这个判断证明了 listen(2)是可以重复调用地（当然是在转向 TCP_LISTEN 后没有再进行状态变迁*/ 
        if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN))) 
                goto out; 
 
        /*  如果接口已经处理 listen 状态，只修改其 max_backlog，否则先调用 tcp_listen_start，继续设置协议的 listen 状态  */ 
        if (old_state != TCP_LISTEN) { 
                err = tcp_listen_start(sk); 
                if (err) 
                        goto out; 
        } 
        sk->sk_max_ack_backlog = backlog; 
        err = 0; 
 
out: 
        release_sock(sk); 
        return err; 
}
 
inet_listen 函数在确认 sock->state 和 sk->sk_state 状态后，会进一步调用 tcp_listen_start 函数，最且最后设置 sk_max_ack_backlog  。 
 
tcp 的 tcp_listen_start 函数，完成两个重要的功能，一个是初始化 sk 的一些相关成员变量，另一方面是切换有限状态机的状态。 sk_max_ack_backlog表示监听时最大的 backlog 数量，它由用户空间传递的参数决定。而 sk_ack_backlog表示当前的的 backlog数量。 
 
当 tcp 服务器收到一个 syn 报文时，它表示了一个连接请求的到达。内核使用了一个 hash 表来维护这个连接请求表： 
struct tcp_listen_opt 
{ 
        u8                        max_qlen_log;        /* log_2 of maximal queued SYNs */ 
        int                        qlen; 
        int                        qlen_young; 
        int                        clock_hand; 
        u32                        hash_rnd; 
        struct open_request        *syn_table[TCP_SYNQ_HSIZE]; 
}; 
 
syn_table,  是open_request结构，就是连接请求表，连中的最大项，也就是最大允许的 syn 报文的数量，由 max_qlen_log 来决定。当套接字进入 listen 状态，也就是说可以接收 syn 报文了，那么在此之前，需要先初始化这个表：  

int tcp_listen_start(struct sock *sk) 
{ 
        struct inet_sock *inet = inet_sk(sk);                //获取 inet结构指针 
        struct tcp_sock *tp = tcp_sk(sk);                //获取协议指针 
        struct tcp_listen_opt *lopt; 
         
        //初始化 sk 相关成员变量 
        sk->sk_max_ack_backlog = 0; 
        sk->sk_ack_backlog = 0; 
         
        tp->accept_queue = tp->accept_queue_tail = NULL; 
        rwlock_init(&tp->syn_wait_lock); 
        tcp_delack_init(tp); 
         
        //初始化连接请求 hash 表 
        lopt = kmalloc(sizeof(struct tcp_listen_opt), GFP_KERNEL); 
        if (!lopt) 
                return -ENOMEM; 
 
        memset(lopt, 0, sizeof(struct tcp_listen_opt)); 
        //初始化 hash 表容量，最小为 6，其实际值由 sysctl_max_syn_backlog 决定 
        for (lopt->max_qlen_log = 6; ; lopt->max_qlen_log++) 
                if ((1 << lopt->max_qlen_log) >= sysctl_max_syn_backlog) 
                        break; 
        get_random_bytes(&lopt->hash_rnd, 4); 
 
        write_lock_bh(&tp->syn_wait_lock); 
        tp->listen_opt = lopt; 
        write_unlock_bh(&tp->syn_wait_lock); 
 
        /* There is race window here: we announce ourselves listening, 
         * but this transition is still not validated by get_port(). 
         * It is OK, because this socket enters to hash table only 
         * after validation is complete. 
         */ 
         /*  修改状态机状态，表示进入 listen 状态，根据作者注释，当宣告自己进入 listening 状态后，但是这个状态转换并没有得到 get_port 的确  认。所以需要调用 get_port()函数。但是对于一点，暂时还没有完全搞明白，只有留待后面再来分析它 */ 
        sk->sk_state = TCP_LISTEN; 
        if (!sk->sk_prot->get_port(sk, inet->num)) { 
                inet->sport = htons(inet->num); 
                 sk_dst_reset(sk); 
                sk->sk_prot->hash(sk); 
 
                return 0; 
        } 
 
        sk->sk_state = TCP_CLOSE; 
        write_lock_bh(&tp->syn_wait_lock); 
        tp->listen_opt = NULL; 
        write_unlock_bh(&tp->syn_wait_lock); 
        kfree(lopt); 
        return -EADDRINUSE; 
}
 
在切换了有限状态机状态后，调用了 
sk->sk_prot->hash(sk);
也就是 tcp_v4_hash()函数。这里涉到到另一个 hash 表：TCP监听 hash 表。 
 
二、TCP监听 hash表
所谓 TCP 监听表，指的就内核维护“当前有哪些套接字在监听”的一个表，当一个数据包进入 TCP栈的时候，内核查询这个表中对应的 sk，以找到相应的数据  结构。 （因为 sk 是面向网络栈调用的，找到了 sk，就找到了 tcp_sock，就找到了 inet_sock，就找到了 sock，就找到了 fd……就到了组  织了）。 
 
TCP所有的 hash 表都用了tcp_hashinfo来封装，前面分析 bind已见过它： 
extern struct tcp_hashinfo { 
                 …… 
        /* All sockets in TCP_LISTEN state will be in here.  This is the only 
         * table where wildcard'd TCP sockets can exist.  Hash function here 
         * is just local port number. 
         */ 
        struct hlist_head __tcp_listening_hash[TCP_LHTABLE_SIZE]; 
 
                 …… 
        spinlock_t __tcp_portalloc_lock; 
} tcp_hashinfo; 
 
#define tcp_listening_hash (tcp_hashinfo.__tcp_listening_hash)
 
函数 tcp_v4_hash 将一个处理监听状态下的 sk 加入至这个 hash 表： 
static void tcp_v4_hash(struct sock *sk) 
{ 
        if (sk->sk_state != TCP_CLOSE) { 
                local_bh_disable();                 __tcp_v4_hash(sk, 1); 
                local_bh_enable(); 
        } 
}

因为__tcp_v4_hash 不只用于监听 hash 表，它也用于其它 hash 表，其第二个参数 listen_possible 为真的时候，表示处理的是监听 hash表： 
static __inline__ void __tcp_v4_hash(struct sock *sk, const int listen_possible) 
{ 
        struct hlist_head *list; 
        rwlock_t *lock; 
 
        BUG_TRAP(sk_unhashed(sk)); 
        if (listen_possible && sk->sk_state == TCP_LISTEN) { 
                list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)]; 
                lock = &tcp_lhash_lock; 
                tcp_listen_wlock(); 
        } else { 
                                …… 
        } 
        __sk_add_node(sk, list); 
        sock_prot_inc_use(sk->sk_prot); 
        write_unlock(lock); 
        if (listen_possible && sk->sk_state == TCP_LISTEN) 
                wake_up(&tcp_lhash_wait); 

}

else 中的部份用于另一个 hash 表，暂时不管它。代表很简单，如果确认是处理的是监听 hash 表。则先根据 sk计算一个 hash 值，在hash 桶中找到入口。再调用__sk_add_node 加入至该 hash 链。 
 
tcp_sk_listen_hashfn()函数事实上是 tcp_lhashfn 的包裹，前面已经分析过了。 
 
__sk_add_node()函数也就是一个简单的内核 hash处理函数 hlist_add_head()的包裹： 
static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list) 
{ 
        hlist_add_head(&sk->sk_node, list); 
}
 
小结 
 
一个套接字的 listen，主要需要做的工作有以下几件： 
1、初始化 sk 相关的成员变量，最重要的是 listen_opt，也就是连接请求 hash 表。 
2、将 sk 的有限状态机转换为 TCP_LISTEN，即监听状态； 
3、将 sk 加入监听 hash表； 
4、设置允许的最大请求积压数，也就是 sk 的成员 sk_max_ack_backlog 的值。