TCP半连接全连接（二） -- 半连接队列代码逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
// linux-5.10.176\include\net\sock.h
struct sock {
    struct sock_common  __sk_common;
    socket_lock_t       sk_lock;
    atomic_t        sk_drops;
    int         sk_rcvlowat;
    struct sk_buff_head sk_error_queue;
    struct sk_buff      *sk_rx_skb_cache;
    struct sk_buff_head sk_receive_queue;
    ...
    struct proto		*skc_prot;
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// linux-5.10.10/include/net/inet_sock.h
struct inet_sock {
    /* sk and pinet6 has to be the first two members of inet_sock */
    struct sock		sk;
#if IS_ENABLED(CONFIG_IPV6)
    struct ipv6_pinfo	*pinet6;
#endif
    /* Socket demultiplex comparisons on incoming packets. */
#define inet_daddr		sk.__sk_common.skc_daddr
#define inet_rcv_saddr		sk.__sk_common.skc_rcv_saddr
#define inet_dport		sk.__sk_common.skc_dport
#define inet_num		sk.__sk_common.skc_num
    ...
    __u8			min_ttl;
    __u8			mc_ttl;
    ...
};

1
2
3
4
5
6
7
8
9
10
// linux-5.10.10/include/net/inet_connection_sock.h
struct inet_connection_sock {
    /* inet_sock has to be the first member! */
    struct inet_sock	  icsk_inet;
    // 里面包含全连接队列、以及半连接队列长度等信息
    struct request_sock_queue icsk_accept_queue;
    struct inet_bind_bucket	  *icsk_bind_hash;
    unsigned long		  icsk_timeout;
    ...
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// linux-5.10.10/include/linux/tcp.h
struct tcp_sock {
    /* inet_connection_sock has to be the first member of tcp_sock */
    struct inet_connection_sock	inet_conn;
    u16	tcp_header_len;	/* Bytes of tcp header to send		*/
    u16	gso_segs;	/* Max number of segs per GSO packet	*/
    ...
    u32	snd_wnd;	/* The window we expect to receive	*/
    u32	max_window;	/* Maximal window ever seen from peer	*/
    ...
    u32	snd_cwnd;	/* Sending congestion window		*/
    u32	snd_cwnd_cnt;	/* Linear increase counter		*/
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// linux-5.10.10/net/ipv4/inet_connection_sock.c
int inet_csk_listen_start(struct sock *sk, int backlog)
{
    // 转换成面向连接的sock
    struct inet_connection_sock *icsk = inet_csk(sk);
    // 转换成基于网络的sock
    struct inet_sock *inet = inet_sk(sk);
    int err = -EADDRINUSE;
    
    // icsk_accept_queue里面包含全连接队列、以及半连接队列长度等信息
    // 此处仅初始化了一些成员变量，不同版本内核实现有差异（参考链接里是3.10，里面做了内存申请，实现差异较大）
    reqsk_queue_alloc(&icsk->icsk_accept_queue);
    ...
    // 设置 socket 状态为 LISTEN
    inet_sk_state_store(sk, TCP_LISTEN);
    // TCP协议初始化时，注册的函数为 inet_csk_get_port
    // 用来处理TCP端口绑定操作，里面逻辑比较复杂，本文先不涉及
    if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
        inet->inet_sport = htons(inet->inet_num);

        sk_dst_reset(sk);
        // TCP注册的函数是 inet_hash
        err = sk->sk_prot->hash(sk);

        if (likely(!err))
            return 0;
    }
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// linux-5.10.10/net/core/request_sock.c
void reqsk_queue_alloc(struct request_sock_queue *queue)
{
    spin_lock_init(&queue->rskq_lock);

    spin_lock_init(&queue->fastopenq.lock);
    queue->fastopenq.rskq_rst_head = NULL;
    queue->fastopenq.rskq_rst_tail = NULL;
    // 半连接队列长度初始化
    queue->fastopenq.qlen = 0;

    // 全连接队列，链表头初始化
    queue->rskq_accept_head = NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// linux-5.10.10/include/net/request_sock.h
// 而3.10中，还包含了显式表示半连接队列的：`struct listen_sock *listen_opt;`
struct request_sock_queue {
    spinlock_t		rskq_lock;
    u8			rskq_defer_accept;

    u32			synflood_warned;
    // 半连接队列长度
    atomic_t		qlen;
    atomic_t		young;

    // 全连接队列，链表头
    struct request_sock	*rskq_accept_head;
    struct request_sock	*rskq_accept_tail;
    struct fastopen_queue	fastopenq;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// linux-5.10.10/net/ipv4/tcp_ipv4.c
const struct inet_connection_sock_af_ops ipv4_specific = {
    // 发送数据的函数。用于将数据从传输层（TCP）发送到网络层（IP）
    .queue_xmit	   = ip_queue_xmit,
    // 用于计算校验和的函数
    .send_check	   = tcp_v4_send_check,
    .rebuild_header	   = inet_sk_rebuild_header,
    .sk_rx_dst_set	   = inet_sk_rx_dst_set,
    // 处理SYN段的函数。在TCP三次握手的开始阶段被调用，用于处理来自客户端的SYN包
    .conn_request	   = tcp_v4_conn_request,
    // 创建和初始化新socket的函数。在TCP三次握手完成后被调用，用于为新的连接创建一个传输控制块（TCB）并初始化它
    .syn_recv_sock	   = tcp_v4_syn_recv_sock,
    .net_header_len	   = sizeof(struct iphdr),
    ...
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
// linux-5.10.10/net/ipv4/tcp_ipv4.c
// 初始化时注册的处理第一次SYN的函数
// sk是socket， skb是数据包
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
    // 如果是广播或者组播的SYN请求包，直接drop
    /* Never answer to SYNs send to broadcast or multicast */
    if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
        goto drop;

    // 处理请求，处理类通过参数传入(结构体指针模拟多态) tcp_request_sock_ops 和 tcp_request_sock_ipv4_ops
    // 具体初始化分别为：`struct request_sock_ops tcp_request_sock_ops` 和 `const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops`
    return tcp_conn_request(&tcp_request_sock_ops,
                &tcp_request_sock_ipv4_ops, sk, skb);

drop:
    tcp_listendrop(sk);
    return 0;
}

// request_sock_ops是用于定义连接请求（request socket）操作的结构体
/* 
 在 TCP/IP 协议栈中，当一个连接请求（如 SYN 包）到达时，内核不会立即创建一个完整的套接字（socket），
 而是先创建一个连接请求套接字（request socket），这个套接字只包含建立连接所需的最少信息。
 一旦连接被确认（如收到 SYN/ACK 和 ACK），这个连接请求套接字就会被转换为一个完整的套接字。 
*/
struct request_sock_ops tcp_request_sock_ops __read_mostly = {
    .family		=	PF_INET,
    .obj_size	=	sizeof(struct tcp_request_sock),
    // 当需要重传 SYN/ACK 响应时调用的函数
    .rtx_syn_ack	=	tcp_rtx_synack,
    // 发送ACK响应的函数
    .send_ack	=	tcp_v4_reqsk_send_ack,
    // 当请求套接字不再需要时调用的析构函数，用于释放资源
    .destructor	=	tcp_v4_reqsk_destructor,
    // 发送RST响应的函数，即拒绝连接请求
    .send_reset	=	tcp_v4_send_reset,
    // 当SYN/ACK超时时调用
    .syn_ack_timeout =	tcp_syn_ack_timeout,
};

// 虽然跟上面全局变量重名，但这里是一个结构体
/*
 该结构是 TCP 协议栈用于扩展 struct request_sock_ops 结构体以处理 TCP 特定的连接请求操作的结构体。
 由于 TCP 连接建立过程比一些其他协议（如 UDP）更复杂，因此 TCP 需要额外的函数和逻辑来处理 SYN 包的接收、确认、超时等情况。
*/
const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
    .mss_clamp	=	TCP_MSS_DEFAULT,
#ifdef CONFIG_TCP_MD5SIG
    .req_md5_lookup	=	tcp_v4_md5_lookup,
    .calc_md5_hash	=	tcp_v4_md5_hash_skb,
#endif
    // 初始化TCP请求套接字的函数
    .init_req	=	tcp_v4_init_req,
#ifdef CONFIG_SYN_COOKIES
    .cookie_init_seq =	cookie_v4_init_sequence,
#endif
    .route_req	=	tcp_v4_route_req,
    // 初始化TCP序列号的函数
    .init_seq	=	tcp_v4_init_seq,
    // 初始化TCP时间戳偏移的函数，时间戳用于计算往返时间（RTT）和防止被包裹的序列号
    .init_ts_off	=	tcp_v4_init_ts_off,
    // 发送SYN/ACK响应的函数
    .send_synack	=	tcp_v4_send_synack,
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// linux-5.10.10/net/ipv4/tcp_input.c
// 处理第一次SYN请求
int tcp_conn_request(struct request_sock_ops *rsk_ops,
             const struct tcp_request_sock_ops *af_ops,
             struct sock *sk, struct sk_buff *skb)
{
    ...
    // tcp_syncookies：1表示当半连接队列满时才开启；2表示无条件开启功能，此处可看到就算半连接队列满了也不drop
    // inet_csk_reqsk_queue_is_full：判断半连接队列是否满(相对于4.4之前的内核，之后内核中半连接队列最大长度也和全连接队列一样)
    if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
         inet_csk_reqsk_queue_is_full(sk)) && !isn) {
        want_cookie = tcp_syn_flood_action(sk, rsk_ops->slab_name);
        if (!want_cookie)
            goto drop;
    }
    ...
    // 检查当前 sock 的全连接队列是否满
    /*
        上面是：inet_csk(sk)->icsk_accept_queue->qlen，判断的是半连接队列长度
        下面是：sk->sk_ack_backlog
    */ 
    if (sk_acceptq_is_full(sk)) {
        NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
        goto drop;
    }
    // 创建一个request_sock，socket状态为：TCP_NEW_SYN_RECV;
    // 里面包含一个引用计数，涉及sock的管理，4.4做的内存优化，暂忽略
    // 这里第3个参数，如果没开启cookie则传入true，一般是开的，所以传false
    req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
    if (!req)
        goto drop;
    ...
    if (!want_cookie && !isn) {
        // 没开启syncookies时，若 `max_syn_backlog - 半连接长度` < max_syn_backlog>>2，则丢弃请求包
        if (!net->ipv4.sysctl_tcp_syncookies &&
            (net->ipv4.sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
             (net->ipv4.sysctl_max_syn_backlog >> 2)) &&
            !tcp_peer_is_proven(req, dst)) {
            ...
            goto drop_and_release;
        }
        ...
    }
    ...
    // 发送SYN+ACK，TCP协议注册的是 tcp_v4_send_synack 里面会生成应答报文
    if (fastopen_sk) {
        ...
        af_ops->send_synack(fastopen_sk, dst, &fl, req,
                    &foc, TCP_SYNACK_FASTOPEN, skb);
        ...
    }else {
        ...
        af_ops->send_synack(sk, dst, &fl, req, &foc,
                !want_cookie ? TCP_SYNACK_NORMAL : TCP_SYNACK_COOKIE, skb);
        ...
    }
    // 减少一个引用
    // 5.10新内核 共用一份空间 ？
    reqsk_put(req);
    return 0;

drop_and_release:
    dst_release(dst);
drop_and_free:
    __reqsk_free(req);
drop:
    // 丢弃包
    tcp_listendrop(sk);
    return 0;
}

1
2
3
4
5
6
7
8
9
// linux-5.10.10/include/net/inet_connection_sock.h
// 判断半连接队列是否已满
static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk)
{
    // sk->sk_max_ack_backlog，之前跟踪listen，可以看到是将 min(backlog,somaxconn) 赋值给了它
    // 半连接队列 >= 最大半连接队列数量（相对于4.4之前内核，新内核的全连接队列和半连接队列最大长度一样。队列是同一个，根据状态区分？）
    // 半连接队列的长度，这里取的是inet_connection_sock.icsk_accept_queue.qlen
    return inet_csk_reqsk_queue_len(sk) >= sk->sk_max_ack_backlog;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// linux-3.10.89/net/ipv4/af_inet.c
int inet_listen(struct socket *sock, int backlog)
{
    struct sock *sk = sock->sk;
    unsigned char old_state;
    int err;
    ...
    if (old_state != TCP_LISTEN) {
        ...
        // 初始化半连接队列和
        err = inet_csk_listen_start(sk, backlog);
        if (err)
            goto out;
    }
    sk->sk_max_ack_backlog = backlog;
    err = 0;
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// linux-3.10.89/net/ipv4/inet_connection_sock.c
// nr_table_entries传入的是 backlog
int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)
{
    struct inet_sock *inet = inet_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    // 申请半连接队列的空间，初始化全连接队列为NULL
    int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);
    ...
    // 设置socket状态为 LISTEN
    sk->sk_state = TCP_LISTEN;
    // TCP协议初始化时指定了： inet_csk_get_port
    // 用来处理TCP端口绑定操作，里面逻辑比较复杂，本文先不涉及
    if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
        inet->inet_sport = htons(inet->inet_num);

        sk_dst_reset(sk);
        // inet_hash
        sk->sk_prot->hash(sk);

        return 0;
    }
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// linux-3.10.89/include/net/request_sock.h
struct request_sock_queue {
    // 全连接队列，是一个先进先出(FIFO)的链表结构
    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 fastopen_queue	*fastopenq; 
};

struct listen_sock {
    // 半连接队列长度的log2对数
    u8			max_qlen_log;
    u8			synflood_warned;
    /* 2 bytes hole, try to use */
    int			qlen;
    int			qlen_young;
    int			clock_hand;
    u32			hash_rnd;
    // 半连接队列长度
    u32			nr_table_entries;
    // 此处实际以hash表方式管理，用于第三次握手时快速地查找出来第一次握手时留存的`request_sock`对象
    struct request_sock	*syn_table[0];
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// linux-3.10.89/net/core/request_sock.c
// nr_table_entries传入的是 backlog(listen时传入的参数)
int reqsk_queue_alloc(struct request_sock_queue *queue,
              unsigned int nr_table_entries)
{
    size_t lopt_size = sizeof(struct listen_sock);
    struct listen_sock *lopt;

    // min(backlog, tcp_max_syn_backlog)
    nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);
    // 取 max(8, nr_table_entries)
    nr_table_entries = max_t(u32, nr_table_entries, 8);
    // 2倍（结果按2^n取整)
    nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);
    // 申请空间
    lopt_size += nr_table_entries * sizeof(struct request_sock *);
    if (lopt_size > PAGE_SIZE)
        lopt = vzalloc(lopt_size);
    else
        lopt = kzalloc(lopt_size, GFP_KERNEL);
    if (lopt == NULL)
        return -ENOMEM;

    // 此处含义：取 max( 3, log2(nr_table_entries) )
    // 每次 1<<max_qlen_log即乘2，直到>=nr_table_entries，即nr_table_entries以2为底
    for (lopt->max_qlen_log = 3;
         (1 << lopt->max_qlen_log) < nr_table_entries;
         lopt->max_qlen_log++);

    get_random_bytes(&lopt->hash_rnd, sizeof(lopt->hash_rnd));
    rwlock_init(&queue->syn_wait_lock);
    // 全连接队列 链表头
    queue->rskq_accept_head = NULL;
    // 上述计算的半连接长度限制
    lopt->nr_table_entries = nr_table_entries;

    write_lock_bh(&queue->syn_wait_lock);
    // struct listen_sock *lopt; 即我们常说的 半连接队列
    queue->listen_opt = lopt;
    write_unlock_bh(&queue->syn_wait_lock);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// linux-3.10.89/net/ipv4/tcp_ipv4.c
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
    ...
    struct request_sock *req;
    struct inet_request_sock *ireq;
    struct tcp_sock *tp = tcp_sk(sk);
    ...
    struct sk_buff *skb_synack;
    ...
    // 半连接队列是否满了
    // queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log
    // queue是指：&inet_csk(sk)->icsk_accept_queue
    if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
        want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
        if (!want_cookie)
            goto drop;
    }

    // 全连接队列是否满了 （若满，且有 young_ack，则直接丢弃）
    // sk->sk_ack_backlog > sk->sk_max_ack_backlog
    if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
        NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
        goto drop;
    }

    // 都未超出限制，则申请空间
    req = inet_reqsk_alloc(&tcp_request_sock_ops);
    if (!req)
        goto drop;
    ...
    // 生成需要应答的SYN+ACK报文
    skb_synack = tcp_make_synack(sk, dst, req,
        fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);

    if (skb_synack) {
        // 检查报文
        __tcp_v4_send_check(skb_synack, ireq->loc_addr, ireq->rmt_addr);
        skb_set_queue_mapping(skb_synack, skb_get_queue_mapping(skb));
    } else
        goto drop_and_free;

    if (likely(!do_fastopen)) {
        int err;
        // 发送报文，IP层
        err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
             ireq->rmt_addr, ireq->opt);
        err = net_xmit_eval(err);
        if (err || want_cookie)
            goto drop_and_free;

        tcp_rsk(req)->snt_synack = tcp_time_stamp;
        tcp_rsk(req)->listener = NULL;
        // 加到半连接队列中 (SYN队列，实际是hash表)
        inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
        ...
    }
    ...
    return 0;

drop_and_release:
    dst_release(dst);
drop_and_free:
    reqsk_free(req);
drop:
    NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
// linux-3.10.89/include/uapi/linux/snmp.h
/* linux mib definitions */
enum
{
    LINUX_MIB_NUM = 0,
    ...
    LINUX_MIB_LISTENOVERFLOWS,		/* ListenOverflows */
    LINUX_MIB_LISTENDROPS,			/* ListenDrops */
    ...
}

1
2
3
4
5
6
7
8
9
// statistics.c
struct entry Tcpexttab[] =
{
    ...
    { "ListenOverflows", N_("%u times the listen queue of a socket overflowed"),
      opt_number },
    { "ListenDrops", N_("%u SYNs to LISTEN sockets dropped"), opt_number },
    ...
}