linux里的backlog详解

问题

我们在Linux上服务器起了一个serversocket，并且设置了backlog为2，并没有让serversock.accept()

 在客户端上，我们一个一个的启动了连接socket, 当连接数目超过3的时候，客户端依然可以继续新建连接。

什么是backlog

说起backlog, 都会想起socket编程中的listen backlog 参数,而这个backlog 是linux内核中处理的backlog么？

[cpp] view plain copy print ?

1. int listen(int sockfd, int backlog)  

listen 中的backlog解释

The backlog argument defines the maximum length to which the queue of pending connections for sockfd may grow. If a connection request arrives when the queue is full, the client may receive an error with an indication of ECONNREFUSED or, if the underlying protocol supports retransmission, the request may be ignored so that a later reattempt at connection succeeds.

实际上在linux内核2.2版本以后，backlog参数控制的是已经握手成功的还在accept queue的大小。

握手过程中的结构体

[cpp] view plain copy print ?

1. struct request_sock_queue {  
2. /*Points to the request_sock accept queue, when after 3 handshake will add the request_sock from syn_table to here*/  
3.     struct request_sock    *rskq_accept_head;  
4.     struct request_sock    *rskq_accept_tail;  
5.     rwlock_t        syn_wait_lock;  
6.     u8            rskq_defer_accept;  
7.     /* 3 bytes hole, try to pack */  
8.     struct listen_sock    *listen_opt;  
9. };  
10. struct listen_sock {  
11.     u8            max_qlen_log; /*2^max_qlen_log is the length of the accpet queue, max of max_qlen_log is 10. (2^10=1024)*/  
12.     /* 3 bytes hole, try to use */  
13.     int            qlen; /* qlen is the current length of the accpet queue*/  
14.     int            qlen_young;  
15.     int            clock_hand;  
16.     u32            hash_rnd;  
17.     u32            nr_table_entries; /*nr_table_entries is the number of the syn_table,max is 512*/  
18.     struct request_sock    *syn_table[0];  
19. };  
20. struct request_sock {  
21.     struct request_sock     *dl_next; /* Must be first member! */  
22.     u16             mss;  
23.     u8              retrans;  
24.     u8              cookie_ts; /* syncookie: encode tcpopts in timestamp */  
25.     /* The following two fields can be easily recomputed I think -AK */  
26.     u32             window_clamp; /* window clamp at creation time */  
27.     u32             rcv_wnd;      /* rcv_wnd offered first time */  
28.     u32             ts_recent;  
29.     unsigned long           <span style="color:#ff0000;">expires</span>;  
30.     const struct request_sock_ops   *rsk_ops;  
31.     struct sock         *sk;  
32.     u32             secid;  
33.     u32             peer_secid;  
34. };  
35. struct sock{  
36. <span style="white-space:pre">    </span>....  
37.     unsigned short      sk_ack_backlog;  
38.     unsigned short      sk_max_ack_backlog;  
39. <span style="white-space:pre">    </span>.....  
40. }  

首先在linux里可以简单的认为有2个队列，一个就是在握手过程中的队列，而另一个就是握手成功的队列

简单的描述一下3个结构体

request_sock

 是每一个client的连接（无论是握手成功，还是不成功） 里面的 expires代表的是这个request在队列里的存活时间，而 *sk 就是连接成功的socket的数目

request_sock_queue

rskq_accept_head 队列，也就是握手成功的队列，*listen_opt 是指listen过程中的sock

listen_sock

*syn_table 是指握手没有成功的队列，而qlen,qlen_young 分别指的是队列的长度和队列新成员的个数

在结构体中，我们已经清楚的看到了一个listen_sock中的syn_table，另一个是request_sock_queue中的rskq_accept_head，这就是我们刚才说的两个队列，一个是为正在握手的队列，另一个是已经握手成功的队列。

我们在上面都看到了结构体中只是看到了未握手的队列的长度，并没有看到握手的队列长度统计，实际上握手成功的队列长度是在sock 结构中

sock 

当握手成功后每一个client就是一个sock, sk_ack_backlog 是队列长度，而sk_max_ack_backlog是指最大的队列长度

在这里我们会有疑问，难道是没个连接上的 sock都会保留队列的长度么？实际上在此时的sock 代表的是server端listen 的sock而不是客户端的sock,也就是在握手没有成功的过程中，在linux使用的sock都是server的listen的sock, 对客户端只是保留成request_sock

TCP握手的几个阶段

收到客户端的syn请求 ->将这个请求放入syn_table中去->服务器端回复syn-ack->收到客户端的ack->放入accept queue中

我们把整个过程分为5个部分，其中将请求放入syn_table和accept queue中的过程也是backlog相关的，在下面我们会详细阐述。

我们先简单的描述一下几个tcp的操作函数，下面针对的也是ip4协议的

[cpp] view plain copy print ?

1. const struct inet_connection_sock_af_ops ipv4_specific = {  
2.     .queue_xmit    = ip_queue_xmit,  
3.     .send_check    = tcp_v4_send_check,  
4.     .rebuild_header    = inet_sk_rebuild_header,  
5.     .conn_request      = tcp_v4_conn_request,  
6.     .syn_recv_sock     = tcp_v4_syn_recv_sock,  
7.     .remember_stamp    = tcp_v4_remember_stamp,  
8.     .net_header_len    = sizeof(struct iphdr),  
9.     .setsockopt    = ip_setsockopt,  
10.     .getsockopt    = ip_getsockopt,  
11.     .addr2sockaddr     = inet_csk_addr2sockaddr,  
12.     .sockaddr_len      = sizeof(struct sockaddr_in),  
13.     .bind_conflict     = inet_csk_bind_conflict,  
14. #ifdef CONFIG_COMPAT  
15.     .compat_setsockopt = compat_ip_setsockopt,  
16.     .compat_getsockopt = compat_ip_getsockopt,  
17. #endif  
18. };  

在刚才所说的两个步骤，也就是结构体中的 conn_request 和 syn_recv_sock,  所对应的函数是 tcp_v4_conn_request 和 tcp_v4_syn_recv_sock

我们所重点关注的主要是方法中的drop逻辑

tcp_v4_conn_request 函数

[cpp] view plain copy print ?

1. int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)  
2. {  
3.     /* Never answer to SYNs send to broadcast or multicast */  
4.     if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))  
5.         goto drop;  
6.   
7.     /* TW buckets are converted to open requests without 
8.      * limitations, they conserve resources and peer is 
9.      * evidently real one. 
10.      */  
11.     if (inet_csk_reqsk_queue_is_full(sk) && !isn) {  
12. #ifdef CONFIG_SYN_COOKIES  
13.         if (sysctl_tcp_syncookies) {  
14.             want_cookie = 1;  
15.         } else  
16. #endif  
17.         goto drop;  
18.     }  
19.   
20.     /* Accept backlog is full. If we have already queued enough 
21.      * of warm entries in syn queue, drop request. It is better than 
22.      * clogging syn queue with openreqs with exponentially increasing 
23.      * timeout. 
24.      */  
25.     if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)  
26.         goto drop;  
27. ....  
28. }  

1. inet_csk_reqsk_queue_is_full(sk)

判断的是  queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;

这里有个 qlen 代表的是listen_opt的 syn_table的长度，那什么是max_qlen_log呢？

[cpp] view plain copy print ?

1. nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);  
2. nr_table_entries = max_t(u32, nr_table_entries, 8);  
3. nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);  
4. for (lopt->max_qlen_log = 3;  
5.          (1 << lopt->max_qlen_log) < nr_table_entries;  
6.          lopt->max_qlen_log++);  

也就是max_qlen 是listen 传入的backlog和sysctl_max_syn_backlog最小值，并且一定大于16 , roudup_pow_of_two 代表着找最靠近nr_table_entries＋1的2的倍数 sysctl_max_syn_backlog 就是我们熟悉的

/proc/sys/net/ipv4/tcp_max_syn_backlog

我们看一下listen 函数在kernel的实现

[cpp] view plain copy print ?

1. SYSCALL_DEFINE2(listen, int, fd, int, backlog)  
2. {  
3.     struct socket *sock;  
4.     int err, fput_needed;  
5.     int somaxconn;  
6.   
7.     sock = sockfd_lookup_light(fd, &err, &fput_needed);  
8.     if (sock) {  
9.         <span style="color: rgb(255, 102, 102);">somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;  
10.         if ((unsigned)backlog > somaxconn)  
11.             backlog = somaxconn;</span>  
12.   
13.         err = security_socket_listen(sock, backlog);  
14.         if (!err)  
15.             err = sock->ops->listen(sock, backlog);  
16.   
17.         fput_light(sock->file, fput_needed);  
18.     }  
19.     return err;  
20. }  

我们清楚的看到backlog 并不是按照你调用listen的所设置的backlog大小，实际上取的是backlog和somaxconn的最小值

somaxconn的值定义在

[cpp] view plain copy print ?

1. /proc/sys/net/core/somaxconn  

2.sk_acceptq_is_full

[cpp] view plain copy print ?

1. static inline int sk_acceptq_is_full(struct sock *sk)  
2. {  
3.     return sk->sk_ack_backlog > sk->sk_max_ack_backlog;  
4. }  
5. int inet_listen(struct socket *sock, int backlog)  
6. {  
7. <span style="white-space:pre">    </span>sk->sk_max_ack_backlog = backlog;  
8. }  

就是等于我们刚才在前面部分看到的listen中的值

3.inet_csk_reqsk_queue_young

在判断sk_acceptq_is_full 的情况下，同是也要求了判断inet_csk_reqsk_queue_young>1,也就是刚才的结构体listen_sock的qlen_young

qlen_young 是对syn_table的计数,进入 syn_table 加1，出了syn_table  -1

有的人可能会有疑问了

如果accept queue满了，那么qlen_young不就是一直增加，而新来的客户端都会被条件if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) 而drop syn的ack包，那么客户端会出现connected timeout, 而实际上你在测试linux的环境中会发现并没有出现这样的情况。

实际上linux在server起socket的时候会调用tcp_keepalive_timer启动tcp_synack_timer，会调用函数inet_csk_reqsk_queue_prune

[cpp] view plain copy print ?

1. if (sk->sk_state == TCP_LISTEN) {  
2.     tcp_synack_timer(sk);  
3.     goto out;  

[cpp] view plain copy print ?

1. static void tcp_synack_timer(struct sock *sk)  
2. {  
3.     inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,  
4.                    TCP_TIMEOUT_INIT, TCP_RTO_MAX);  
5. }  

而inet_csk_reqsk_queue_prune会在去检查syn的table, 而删除一些这个request 过期后并且完成retry 的syn ack包的请求

为了提高inet_csk_reqsk_queue_prune的效率，在request_sock 里加入了 expires(才前面的结构体中已经提到过) , 这个expires初始值是hardcode的3HZ 时间， inet_csk_reqsk_queue_prune会轮训syn_table里的已经exprie request, 发现如果还没有到到retry的次数,那么会增加expire的时间直到重试结束，而expire的时间为剩余retry 次数*3HZ ，并且不大于120HZ

关于retry, retry的参数可以通过设置 

[cpp] view plain copy print ?

1. /proc/sys/net/ipv4/tcp_syn_retries  

当然你可以通过设置

/proc/sys/net/ipv4/tcp_abort_on_overflow 为1 不允许syn ack 重试

因为被inet_csk_reqsk_queue_prune函数清除了syn_table，在没有并发的前提下基本上不会出现inet_csk_reqsk_queue_young>1的情况，也就是说不会出现drop sync的情况，在客户端表现，不会出现connect timeout 的情况（这里的实现linux和mac的实现有很大的不同）而刚开始的问题也能得到合理的解释了

通过函数tcp_v4_conn_request的分析，在linux的设计初衷是尽力的允许新的连接握手，而期望服务器端能更快的响应accept.

我们也许会问，刚才的服务器syn ack回去后，如果客户端也回复了ack的话，而此时accept的queue满了，将会如何处理

我们回到前面提到的步骤，处理客户端的ack 函数也就是

tcp_v4_syn_recv_sock 函数

[cpp] view plain copy print ?

1. struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,  
2.                   struct request_sock *req,  
3.                   struct dst_entry *dst)  
4. {  
5.     struct inet_request_sock *ireq;  
6.     struct inet_sock *newinet;  
7.     struct tcp_sock *newtp;  
8.     struct sock *newsk;  
9. #ifdef CONFIG_TCP_MD5SIG  
10.     struct tcp_md5sig_key *key;  
11. #endif  
12.   
13.     if (sk_acceptq_is_full(sk))  
14.         goto exit_overflow;  
15.   
16.     if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)  
17.         goto exit;  
18.   
19.     newsk = tcp_create_openreq_child(sk, req, skb);  
20.     if (!newsk)  
21.         goto exit;  
22.   
23.     newsk->sk_gso_type = SKB_GSO_TCPV4;  
24.     sk_setup_caps(newsk, dst);  
25.   
26.     newtp             = tcp_sk(newsk);  
27.     newinet           = inet_sk(newsk);  
28.     ireq              = inet_rsk(req);  
29.     newinet->inet_daddr   = ireq->rmt_addr;  
30.     newinet->inet_rcv_saddr = ireq->loc_addr;  
31.     newinet->inet_saddr        = ireq->loc_addr;  
32.     newinet->opt       = ireq->opt;  
33.     ireq->opt          = NULL;  
34.     newinet->mc_index     = inet_iif(skb);  
35.     newinet->mc_ttl        = ip_hdr(skb)->ttl;  
36.     inet_csk(newsk)->icsk_ext_hdr_len = 0;  
37.     if (newinet->opt)  
38.         inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;  
39.     newinet->inet_id = newtp->write_seq ^ jiffies;  
40.   
41.     tcp_mtup_init(newsk);  
42.     tcp_sync_mss(newsk, dst_mtu(dst));  
43.     newtp->advmss = dst_metric(dst, RTAX_ADVMSS);  
44.     if (tcp_sk(sk)->rx_opt.user_mss &&  
45.         tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)  
46.         newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;  
47.   
48.     tcp_initialize_rcv_mss(newsk);  
49.   
50. #ifdef CONFIG_TCP_MD5SIG  
51.     /* Copy over the MD5 key from the original socket */  
52.     key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);  
53.     if (key != NULL) {  
54.         /* 
55.          * We're using one, so create a matching key 
56.          * on the newsk structure. If we fail to get 
57.          * memory, then we end up not copying the key 
58.          * across. Shucks. 
59.          */  
60.         char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);  
61.         if (newkey != NULL)  
62.             tcp_v4_md5_do_add(newsk, newinet->inet_daddr,  
63.                       newkey, key->keylen);  
64.         newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;  
65.     }  
66. #endif  
67.   
68.     __inet_hash_nolisten(newsk, NULL);  
69.     __inet_inherit_port(sk, newsk);  
70.   
71.     return newsk;  
72.   
73. exit_overflow:  
74.     NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);  
75. exit:  
76.     NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);  
77.     dst_release(dst);  
78.     return NULL;  
79. }  

我们看到了熟悉的函数 sk_acceptq_is_full， 而在此时在无函数inet_csk_reqsk_queue_young>1来保护，也就是说在此时如果发现queue是满的，将直接丢弃只是统计了参数 LINUX_MIB_LISTENOVERFLOWS， LINUX_MIB_LISTENDROPS而这些参数的值可以通过

netstat -s 来查看到

在函数tcp_v4_syn_recv_sock中我们看到tcp_create_openreq_child，此时才clone出一个新的socket ,也就是只有通过了3次握手后，linux才会产生新的socket, 而在3次握手中所传的socket 实际上是server的listen的 socket, 那也就是说这个socket 只有一个状态TCP_LISTEN

netstat的状态

通过在tcp_rcv_state_process可以置socket 的状态，而我们通常使用netstat 中看到这些socket的状态

[cpp] view plain copy print ?

1. case TCP_SYN_RECV:  
2.             if (acceptable) {  
3.                 tp->copied_seq = tp->rcv_nxt;  
4.                 smp_mb();  
5.                 tcp_set_state(sk, TCP_ESTABLISHED);  

我们看到从 SYN_RECV的状态直接设置成ESTABLISHED，也就是当server收到client的ack回来，状态置为 TCP_SYN_RECV，而马上进入tcp_rcv_state_process函数置为状态ESTABLISHED，基本没有TCP_SYN_RECV 的状态期，但我们通过netstat  的使用，还是会发现有部分socket 还是会处于SYN_RECV状态，实际上这通常是在syn_table的request, 为了显示还没有通过三次握手的连接的状态，这时候request 还在syn table里，并且还没有属于自己的socket对象，linux 把这些信息写到了

[cpp] view plain copy print ?

1. /proc/net/tcp   

而在TCP_SEQ_STATE_OPENREQ 的情况下（就是 syn synack ack）的3个状态下都显示成TCP_SYN_RECV

[cpp] view plain copy print ?

1. static void get_openreq4(struct sock *sk, struct request_sock *req,  
2.              struct seq_file *f, int i, int uid, int *len)  
3. {  
4.     const struct inet_request_sock *ireq = inet_rsk(req);  
5.     int ttd = req->expires - jiffies;  
6.   
7.     seq_printf(f, "%4d: %08X:%04X %08X:%04X"  
8.         " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",  
9.         i,  
10.         ireq->loc_addr,  
11.         ntohs(inet_sk(sk)->inet_sport),  
12.         ireq->rmt_addr,  
13.         ntohs(ireq->rmt_port),  
14.         <span style="color:#ff0000;">TCP_SYN_RECV</span>,  
15.         0, 0, /* could print option size, but that is af dependent. */  
16.         1,    /* timers active (only the expire timer) */  
17.         jiffies_to_clock_t(ttd),  
18.         req->retrans,  
19.         uid,  
20.         0,  /* non standard timer */  
21.         0, /* open_requests have no inode */  
22.         atomic_read(&sk->sk_refcnt),  
23.         req,  
24.         len);  
25. }  

而对ESTABLISHED状态，并不需要server.accept，只要在accept queue里就已经变成状态ESTABLISHED