TCP连接的ACCEPT队列

TCPIP协议 同时被 2 个专栏收录
105 篇文章 6 订阅
23 篇文章 1 订阅

PROC文件somaxconn默认为128,意味着单个套接口队列的长度,可最大监听128个连接。net_defaults_init_net函数初始化此值为宏SOMAXCONN(128)。此处的套接口意指完成TCP三次握手,连接已建立起来的套接口,用户层也还未accept此套接口(此处的套接为子套接口,即子套接口队列)。另外,连接未完成的套接口的数量由/proc/sys/net/ipv4/tcp_max_syn_backlog控制。

# cat /proc/sys/net/core/somaxconn
128

static int __net_init net_defaults_init_net(struct net *net)
{
    net->core.sysctl_somaxconn = SOMAXCONN;
}

连接监听套接口保存在以request_sock_queue结构的成员rskq_accept_head为首的链表中,rskq_accept_tail成员指向链表尾部。这是一个先入先出(FIFO)类型链表。

struct request_sock_queue {
    struct request_sock *rskq_accept_head;
    struct request_sock *rskq_accept_tail;
}; 

套接口函数listen的系统调用指定最大的连接套接口数量(backlog),由其内容可见,用户指定的参数backlog不能大于sysctl_somaxconn的值,否则使用sysctl_somaxconn的值。如需要增大监听的套接口数量,可预先修改PROC文件somaxconn的值。

SYSCALL_DEFINE2(listen, int, fd, int, backlog)
{
    sock = sockfd_lookup_light(fd, &err, &fput_needed);
    if (sock) {
        somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
        if ((unsigned int)backlog > somaxconn)
            backlog = somaxconn;
        err = security_socket_listen(sock, backlog);
        if (!err)
            err = sock->ops->listen(sock, backlog);
	}
}

最终,backlog的值赋给了套接口对应的sock结构的sk_max_ack_backlog成员。

int inet_listen(struct socket *sock, int backlog)
{
    if (old_state != TCP_LISTEN) {
        err = inet_csk_listen_start(sk, backlog);
    }
    sk->sk_max_ack_backlog = backlog;
}

int inet_csk_listen_start(struct sock *sk, int backlog)
{   
    struct inet_connection_sock *icsk = inet_csk(sk);
    
    reqsk_queue_alloc(&icsk->icsk_accept_queue);
    sk->sk_max_ack_backlog = backlog;
    sk->sk_ack_backlog = 0;
}

另外,sock结构中的sk_ack_backlog用于记录当前的队列长度,在inet_csk_listen_start函数中将其初始化为0,最重要的是初始化ACCEPT队列(icsk_accetp_queue)。

加入ACCEPT队列


接收到客户端的第三个握手ACK报文之后,在函数tcp_check_req中,如果一切检查正常的话,使用回调syn_recv_sock处理创建子套接口,之后由函数inet_csk_complete_hashdance将子套接口添加到ACCEPT队列中。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{
    struct sock *child;

    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, req, &own_req);
    if (!child)
        goto listen_overflow;

    sock_rps_save_rxhash(child, skb);
    tcp_synack_rtt_meas(child, req);
    return inet_csk_complete_hashdance(sk, child, req, own_req);
}

如下所示,添加到ACCEPT队列的条件是own_req变量为真,此变量在回调函数syn_recv_sock中赋值,其为真意味着此子套接口已经成功添加到全局的TCP套接口队列中(TCP套接口全局哈希链表为tcp_hashinfo),否则,有一种情况是客户端进行的两次TCP握手,在第二次握手完成之时,第一次握手创建的子接口已添加到全局套接口链表中,导致第二次握手的子套接口添加不成功,own_req为空时需要释放第二次握手创建的子套接口。

struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child, struct request_sock *req, bool own_req)
{
    if (own_req) {
        inet_csk_reqsk_queue_drop(sk, req);
        reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);
        if (inet_csk_reqsk_queue_add(sk, req, child))
            return child;
    }
    /* Too bad, another child took ownership of the request, undo. */
    bh_unlock_sock(child);
    sock_put(child);
    return NULL;
}

函数inet_csk_reqsk_queue_add完成具体的添加工作,新添加进来的子套接口加到ACCEPT队列的尾部。由函数可见ACCEPT队列实际上存储的是请求套接口(request_sock),不过每个请求套接口对应一个子套接口(req->sk),两者是对应的。

struct sock *inet_csk_reqsk_queue_add(struct sock *sk, struct request_sock *req, struct sock *child)
{
    struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;

    if (unlikely(sk->sk_state != TCP_LISTEN)) {

    } else {
        req->sk = child;
        req->dl_next = NULL;
        if (queue->rskq_accept_head == NULL)
            queue->rskq_accept_head = req;
        else
            queue->rskq_accept_tail->dl_next = req;
        queue->rskq_accept_tail = req;
        sk_acceptq_added(sk);
    }
}

函数sk_acceptq_added递增ACCEPT队列长度。

static inline void sk_acceptq_added(struct sock *sk)
{
    sk->sk_ack_backlog++;
}

移出ACCEPT队列 

当用户层调用accept套接口函数时,使用reqsk_queue_remove函数将套接口(已是子套接口)从icsk_accept_queue队列中删除。此处的newsk为新TCP连接的子套接口,返回给用户层。

struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
{
    struct inet_connection_sock *icsk = inet_csk(sk);
    struct request_sock_queue *queue = &icsk->icsk_accept_queue;
    struct request_sock *req;
	struct sock *newsk;

    req = reqsk_queue_remove(queue, sk);
    newsk = req->sk;
}

函数reqsk_queue_remove为简单的链表移除单个元素的操作,rskq_accept_head为链表的头,注意ACCEPT队列总是从头部开始移除队列中的子套接口元素,即用户层的accept操作总是取走队列中的第一个子套接口。

static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue, struct sock *parent)
{        
    struct request_sock *req;

    req = queue->rskq_accept_head;
    if (req) {
        sk_acceptq_removed(parent);
        queue->rskq_accept_head = req->dl_next;
        if (queue->rskq_accept_head == NULL)
            queue->rskq_accept_tail = NULL;
    } 
}

递减队列长度计数。

static inline void sk_acceptq_removed(struct sock *sk)
{
    sk->sk_ack_backlog--;
}

ACCEPT队列满

队列满的判断函数sk_acceptq_is_full如下,

static inline bool sk_acceptq_is_full(const struct sock *sk)
{
    return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
}

队列满的判断在内核中有两处,一处位于TCP三次握手完成,接收到客户端的ACK报文时,见函数tcp_v4_syn_recv_sock中所示,由于此处TCP连接建立完成,需要创建新的子套接口,之后将此子套接口加入到accept队列中,所以先判断accept队列是否已满。满的话不进行后续的子接口创建等操作。

struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb, struct request_sock *req, ...)
{
    if (sk_acceptq_is_full(sk))
        goto exit_overflow;
}

函数tcp_v4_syn_recv_sock由TCP入口函数tcp_v4_rcv调用,要求此时的套接口处于TCP_NEW_SYN_RECV状态,即套接口在等待三次握手的最后一个ACK报文。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, req, &own_req);
}

int tcp_v4_rcv(struct sk_buff *skb)
{
    if (sk->sk_state == TCP_NEW_SYN_RECV) {
        struct request_sock *req = inet_reqsk(sk);
        if (!tcp_filter(sk, skb))
            nsk = tcp_check_req(sk, skb, req, false);
	}
}

第二个队列满的判断位于函数tcp_conn_request中。此处是在接收到一个新的TCP连接请求之时,判断ACCEPT队列是否已满,满的话就不再继续处理,假如继续处理,比如回复客户端SYN+ACK报文,之后客户端发送ACK再次到达之后,就到了前面讲述的第一个队列满的判断点,最终也是不能处理。

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)
{
    if (sk_acceptq_is_full(sk)) {
        NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
        goto drop;
    }
}

函数tcp_conn_request在TCP接收状态机处理函数tcp_rcv_state_process中调用,要求套接口在LISTEN状态接收到SYN报文。

int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    struct inet_connection_sock *icsk = inet_csk(sk);
    const struct tcphdr *th = tcp_hdr(skb);

    switch (sk->sk_state) {
    case TCP_LISTEN:
        if (th->syn) {
            acceptable = icsk->icsk_af_ops->conn_request(sk, skb) >= 0;
            return 0;
        }
}

针对第一处ACCEPT队列满的处理,PROC文件tcp_abort_on_overflow指定了要进行的操作。其默认值为0,置位acked后直接返回;如果不为0,将重置此连接发送TCP的reset报文到对端。如果确认本机的应用程序不能够更快的处理(accept)新进的连接,可置位tcp_abort_on_overflow,但是发送的reset报文会对客户端造成伤害。如果队列满的原因是由于突发的大量连接所导致,之后其会恢复,不建议置位tcp_abort_on_overflow。

$ cat /proc/sys/net/ipv4/tcp_abort_on_overflow
0

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{	
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, req, &own_req);
    if (!child)
        goto listen_overflow;

listen_overflow:
    if (!sock_net(sk)->ipv4.sysctl_tcp_abort_on_overflow) {
        inet_rsk(req)->acked = 1;
        return NULL;
    }
embryonic_reset:
    if (!(flg & TCP_FLAG_RST)) {
        req->rsk_ops->send_reset(sk, skb);
    }
    if (!fastopen) {
        inet_csk_reqsk_queue_drop(sk, req);
        __NET_INC_STATS(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
    }
}

补充

以上讨论的是TCP连接建立后的ACCEPT子套接口队列,但是在这之前(还未创建子套接口)的请求套接口保存在哪里呢?参见文章 https://blog.csdn.net/sinat_20184565/article/details/87709636 讨论的是tcp_max_syn_backlog控制的还未完全建立连接的TCP请求套接口队列的最大长度。但是内核中并没有此队列,所有的请求套接口保存到全局的TCP套接口链表中,使用ACCEPT队列icsk_accept_queue(结构为request_sock_queue)的成员qlen表示此队列的长度。

struct request_sock_queue {
    atomic_t        qlen;
}

在接收到SYN报文后,使用函数inet_csk_reqsk_queue_hash_add处理请求套接口队列,最终由函数reqsk_queue_added增加队列计数。

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)
{
    if (fastopen_sk) {

    } else {
        if (!want_cookie)
            inet_csk_reqsk_queue_hash_add(sk, req, tcp_timeout_init((struct sock *)req));
        af_ops->send_synack(sk, dst, &fl, req, &foc, !want_cookie ? TCP_SYNACK_NORMAL : TCP_SYNACK_COOKIE);
    }
}
static inline void reqsk_queue_added(struct request_sock_queue *queue)
{
    atomic_inc(&queue->young);
    atomic_inc(&queue->qlen);
}

另外一个问题是,在TCP连接建立之后,将子套接口添加到ACCEPT队列之前,需要将全局TCP套接口链表中删除请求套接口(由函数reqsk_queue_unlink完成),并且要递减请求套接口队列的长度(由函数reqsk_queue_removed完成)。

void inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req)
{
    if (reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req)) {
        reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);
        reqsk_put(req);
    }
}
static inline void reqsk_queue_removed(struct request_sock_queue *queue, const struct request_sock *req)
{        
    if (req->num_timeout == 0)
        atomic_dec(&queue->young);
    atomic_dec(&queue->qlen);
} 

 

内核版本 Linux-4.15

 

  • 1
    点赞
  • 0
    评论
  • 2
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值