Linux网络协议栈 -- socket listen监听
2012-07-08 19:57
369 查看
一、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 的值。
对面向连接的协议，在调用 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 的值。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Linux网络协议栈 -- socket listen监听
- Linux网络协议栈之TCP socket/bind/listen/connect/accept/close/shutdown
- linux网络编程常用函数详解与实例（socket-->bind-->listen-->accept）
- linux网络编程常用函数详解与实例（socket-->bind-->listen-->accept）
- 【Linux 内核网络协议栈源码剖析】listen 函数剖析
- Linux网络协议栈 -- socket创建（1）
- linux网络编程二：基础socket, bind, listen, accept, connect
- 【Linux 内核网络协议栈源码剖析】socket 函数剖析
- Linux网络协议栈(一)——Socket入门(1)
- linux网络编程常用函数详解与实例（socket-->bind-->listen-->accept）
- Linux网络协议栈 -- socket bind 地址绑定
- 【Linux 内核网络协议栈源码剖析】socket.c——BSD Socket层（1）
- 【Linux 内核网络协议栈源码剖析】网络栈主要结构介绍（socket、sock、sk_buff，etc）
- Linux网络协议栈(一) -- socket入门(1)
- Linux网络协议栈 -- socket创建（3）
- Linux网络协议栈(二)——套接字缓存(socket buffer)
- Linux 内核网络协议栈源码剖析socket 函数剖析
- Linux网络协议栈(二)——套接字缓存(socket buffer)
- Linux网络协议栈 -- socket accept接收连接
- Linux网络协议栈(一)——Socket入门(1)