問題

我們在linux上服務器起了一個serversocket，并且設置了backlog為2，并沒有讓serversock.accept()

在客戶端上，我們一個一個的啟動了連接socket, 當連接數目超過3的時候，客戶端依然可以繼續新建連接。

什么是backlog

說起backlog, 都會想起socket編程中的listen backlog 參數,而這個backlog 是linux內核中處理的backlog么？

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的大小。

握手過程中的結構體

struct request_sock_queue {
/*Points to the request_sock accept queue, when after 3 handshake will add the request_sock from syn_table to here*/
    struct request_sock    *rskq_accept_head;
    struct request_sock    *rskq_accept_tail;
    rwlock_t        syn_wait_lock;
    u8            rskq_defer_accept;
    /* 3 bytes hole, try to pack */
    struct listen_sock    *listen_opt;
};
struct listen_sock {
    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)*/
    /* 3 bytes hole, try to use */
    int            qlen; /* qlen is the current length of the accpet queue*/
    int            qlen_young;
    int            clock_hand;
    u32            hash_rnd;
    u32            nr_table_entries; /*nr_table_entries is the number of the syn_table,max is 512*/
    struct request_sock    *syn_table[0];
};
struct request_sock {
	struct request_sock		*dl_next; /* Must be first member! */
	u16				mss;
	u8				retrans;
	u8				cookie_ts; /* syncookie: encode tcpopts in timestamp */
	/* The following two fields can be easily recomputed I think -AK */
	u32				window_clamp; /* window clamp at creation time */
	u32				rcv_wnd;	  /* rcv_wnd offered first time */
	u32				ts_recent;
	unsigned long			expires;
	const struct request_sock_ops	*rsk_ops;
	struct sock			*sk;
	u32				secid;
	u32				peer_secid;
};
struct sock{
	unsigned short		sk_ack_backlog;
	unsigned short		sk_max_ack_backlog;
}

首先在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協議的

const struct inet_connection_sock_af_ops ipv4_specific = {
	.queue_xmit	   = ip_queue_xmit,
	.send_check	   = tcp_v4_send_check,
	.rebuild_header	   = inet_sk_rebuild_header,
	.conn_request	   = tcp_v4_conn_request,
	.syn_recv_sock	   = tcp_v4_syn_recv_sock,
	.remember_stamp	   = tcp_v4_remember_stamp,
	.net_header_len	   = sizeof(struct iphdr),
	.setsockopt	   = ip_setsockopt,
	.getsockopt	   = ip_getsockopt,
	.addr2sockaddr	   = inet_csk_addr2sockaddr,
	.sockaddr_len	   = sizeof(struct sockaddr_in),
	.bind_conflict	   = inet_csk_bind_conflict,
#ifdef CONFIG_COMPAT
	.compat_setsockopt = compat_ip_setsockopt,
	.compat_getsockopt = compat_ip_getsockopt,
#endif
};

在剛才所說的兩個步驟，也就是結構體中的 conn_request 和 syn_recv_sock,  所對應的函數是 tcp_v4_conn_request 和 tcp_v4_syn_recv_sock

我們所重點關注的主要是方法中的drop邏輯

tcp_v4_conn_request 函數

int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
	/* Never answer to SYNs send to broadcast or multicast */
	if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
		goto drop;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
	if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
#ifdef CONFIG_SYN_COOKIES
		if (sysctl_tcp_syncookies) {
			want_cookie = 1;
		} else
#endif
		goto drop;
	}

	/* Accept backlog is full. If we have already queued enough
	 * of warm entries in syn queue, drop request. It is better than
	 * clogging syn queue with openreqs with exponentially increasing
	 * timeout.
	 */
	if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
		goto drop;
....
}

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呢？

nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);
nr_table_entries = max_t(u32, nr_table_entries, 8);
nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);
for (lopt->max_qlen_log = 3;
	     (1 << lopt->max_qlen_log) < nr_table_entries;
	     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的實現

SYSCALL_DEFINE2(listen, int, fd, int, backlog)
{
	struct socket *sock;
	int err, fput_needed;
	int somaxconn;
 
	sock = sockfd_lookup_light(fd, &err, &fput_needed);
	if (sock) {
		<span style="color: rgb(255, 102, 102);">somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
		if ((unsigned)backlog > somaxconn)
			backlog = somaxconn;</span>
 
		err = security_socket_listen(sock, backlog);
		if (!err)
			err = sock->ops->listen(sock, backlog);
 
		fput_light(sock->file, fput_needed);
	}
	return err;
}

我們清楚的看到backlog 并不是按照你調用listen的所設置的backlog大小，實際上取的是backlog和somaxconn的最小值

somaxconn的值定義在

/proc/sys/net/core/somaxconn

2.sk_acceptq_is_full

static inline int sk_acceptq_is_full(struct sock *sk)
{
	return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
}
int inet_listen(struct socket *sock, int backlog)
{
    sk->sk_max_ack_backlog = backlog;
}

就是等于我們剛才在前面部分看到的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

 if (sk->sk_state == TCP_LISTEN) {
		tcp_synack_timer(sk);
		goto out;
}

static void tcp_synack_timer(struct sock *sk)
{
	inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
				   TCP_TIMEOUT_INIT, TCP_RTO_MAX);
}

而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的參數可以通過設置 

/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 函數

struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
				  struct request_sock *req,
				  struct dst_entry *dst)
{
	struct inet_request_sock *ireq;
	struct inet_sock *newinet;
	struct tcp_sock *newtp;
	struct sock *newsk;
#ifdef CONFIG_TCP_MD5SIG
	struct tcp_md5sig_key *key;
#endif
 
	if (sk_acceptq_is_full(sk))
		goto exit_overflow;
 
	if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
		goto exit;
 
	newsk = tcp_create_openreq_child(sk, req, skb);
	if (!newsk)
		goto exit;
 
	newsk->sk_gso_type = SKB_GSO_TCPV4;
	sk_setup_caps(newsk, dst);
 
	newtp		      = tcp_sk(newsk);
	newinet		      = inet_sk(newsk);
	ireq		      = inet_rsk(req);
	newinet->inet_daddr   = ireq->rmt_addr;
	newinet->inet_rcv_saddr = ireq->loc_addr;
	newinet->inet_saddr	      = ireq->loc_addr;
	newinet->opt	      = ireq->opt;
	ireq->opt	      = NULL;
	newinet->mc_index     = inet_iif(skb);
	newinet->mc_ttl	      = ip_hdr(skb)->ttl;
	inet_csk(newsk)->icsk_ext_hdr_len = 0;
	if (newinet->opt)
		inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
	newinet->inet_id = newtp->write_seq ^ jiffies;
 
	tcp_mtup_init(newsk);
	tcp_sync_mss(newsk, dst_mtu(dst));
	newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
	if (tcp_sk(sk)->rx_opt.user_mss &&
	    tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
		newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
 
	tcp_initialize_rcv_mss(newsk);
 
#ifdef CONFIG_TCP_MD5SIG
	/* Copy over the MD5 key from the original socket */
	key = tcp_v4_md5_do_lookup(sk, newinet->inet_daddr);
	if (key != NULL) {
		/*
		 * We're using one, so create a matching key
		 * on the newsk structure. If we fail to get
		 * memory, then we end up not copying the key
		 * across. Shucks.
		 */
		char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
		if (newkey != NULL)
			tcp_v4_md5_do_add(newsk, newinet->inet_daddr,
					  newkey, key->keylen);
		newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
	}
#endif
 
	__inet_hash_nolisten(newsk, NULL);
	__inet_inherit_port(sk, newsk);
 
	return newsk;
 
exit_overflow:
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
exit:
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
	dst_release(dst);
	return NULL;
}

我們看到了熟悉的函數 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的狀態

case TCP_SYN_RECV:
			if (acceptable) {
				tp->copied_seq = tp->rcv_nxt;
				smp_mb();
				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 把這些信息寫到了

/proc/net/tcp

而在TCP_SEQ_STATE_OPENREQ 的情況下（就是 syn synack ack）的3個狀態下都顯示成TCP_SYN_RECV

static void get_openreq4(struct sock *sk, struct request_sock *req,
			 struct seq_file *f, int i, int uid, int *len)
{
	const struct inet_request_sock *ireq = inet_rsk(req);
	int ttd = req->expires - jiffies;
 
	seq_printf(f, "%4d: %08X:%04X %08X:%04X"
		" %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
		i,
		ireq->loc_addr,
		ntohs(inet_sk(sk)->inet_sport),
		ireq->rmt_addr,
		ntohs(ireq->rmt_port),
		TCP_SYN_RECV,
		0, 0, /* could print option size, but that is af dependent. */
		1,    /* timers active (only the expire timer) */
		jiffies_to_clock_t(ttd),
		req->retrans,
		uid,
		0,  /* non standard timer */
		0, /* open_requests have no inode */
		atomic_read(&sk->sk_refcnt),
		req,
		len);
}

而對ESTABLISHED狀態，并不需要server.accept，只要在accept queue里就已經變成狀態ESTABLISHED

到此這篇關于詳解linux里的backlog參數的文章就介紹到這了。希望對大家的學習有所幫助，也希望大家多多支持腳本之家。