TCP之延迟ACCEPT

TCPIP协议 专栏收录该内容
105 篇文章 6 订阅

通常情况下,在一个新的TCP连接完成三次握手之后,监听端的accept系统调用就可返回与此对应的子套接口。然而,TCP的延迟ACCEPT功能,允许TCP监听端仅在接收到客户端的数据报文后才去唤醒服务端应用的ACCEPT请求。

 

延迟ACCEPT开启

应用层通过setsockopt系统调用的选项TCP_DEFER_ACCEPT控制延迟ACCEPT功能。用户层下发以秒为单位的数值,内核转换为重传次数值使用,赋值于rskq_defer_accept变量。设置为0秒将关闭此功能。

static int do_tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval, unsigned int optlen)
{
    switch (optname) {
    case TCP_DEFER_ACCEPT:
        /* Translate value in seconds to number of retransmits */
        icsk->icsk_accept_queue.rskq_defer_accept = secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
        break;
}
#define TCP_TIMEOUT_INIT ((unsigned)(1*HZ)) /* RFC6298 2.1 initial RTO value    */
#define TCP_RTO_MAX ((unsigned)(120*HZ))

转换函数secs_to_retrans的第一个参数为用户层下发的秒值,后两个分别为以秒为单位的TCP初始重传超时时长和最大重传超时时长RTO,参见宏定义两者的值为别为1秒和120秒。

如果用户层下发值大于0的话,最终得到的重传次数值在1到255之间。以重传初始时长timeout开始,每次重传时长递增一倍,知道重传超时的最大值rto_max,之后的重传超时不变使用最大值,知道超时时长大于用户下发值为止,推算出对应的重传次数。

/* Convert seconds to retransmits based on initial and max timeout */
static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
{
    if (seconds > 0) {
        int period = timeout;

        res = 1;
        while (seconds > period && res < 255) {
            res++;
            timeout <<= 1;
            if (timeout > rto_max)
                timeout = rto_max;
            period += timeout;
        }
    }
    return res;
}

在用户层使用系统调用getsockopt的选项TCP_DEFER_ACCEPT获取当前的延迟ACCEPT时长值时,内核使用retrans_to_secs函数将重传次数转换为以秒为单位的时间值,返回给用户层。其实现与以上函数secs_to_retrans的逻辑正相反。

static int do_tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, int __user *optlen)
{
    switch (optname) {
    case TCP_DEFER_ACCEPT:
        val = retrans_to_secs(icsk->icsk_accept_queue.rskq_defer_accept, TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
        break;
}
/* Convert retransmits to seconds based on initial and max timeout */
static int retrans_to_secs(u8 retrans, int timeout, int rto_max)
{
    if (retrans > 0) {
        period = timeout;
        while (--retrans) {
            timeout <<= 1;
            if (timeout > rto_max)
                timeout = rto_max;
            period += timeout;
        }
    }
    return period;
}

服务端接收检查


当处于TCP_NEW_SYN_RECV的请求套接口,接收到对端的报文(通常为ACK)之后,调用函数tcp_check_req进行检查。如果此报文的结束序号end_seq等于请求套接口记录的初始接收序号(rcv_isn)加1,通常rcv_isn为SYN报文使用的序列号,意味着当前报文为无数据的单纯ACK确认报文。并且,超时重传的次数还未超出设定的rskq_defer_accept次数值。内核将请求套接口的acked置位,表明已接收到对端ACK报文,但是并不创建相应的子套接口。

struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, struct request_sock *req, bool fastopen)
{
    /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */
    if (req->num_timeout < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept && TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
        inet_rsk(req)->acked = 1;
        __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDEFERACCEPTDROP);
        return NULL;
    }
    child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL, req, &own_req);
	
    return inet_csk_complete_hashdance(sk, child, req, own_req);
}

 

服务端发送超时

当服务端回复给客户端SYN+ACK报文之后,会启动一个(rsk_timer)超时定时器,以便在超时之后还未能接收到客户端相应的ACK报文,重新发送SYN+ACK报文。由以上的函数tcp_check_req的结束可知,如果延长ACCEPT发挥了作用,内核未能创建子套接口,也没调用到能够停止超时定时器的函数inet_csk_complete_hashdance。所以到时间后,超时处理函数reqsk_timer_handler得到运行。

static void reqsk_timer_handler(struct timer_list *t)
{
    struct request_sock *req = from_timer(req, t, rsk_timer);
    struct sock *sk_listener = req->rsk_listener;
    struct net *net = sock_net(sk_listener);
    struct inet_connection_sock *icsk = inet_csk(sk_listener);
    struct request_sock_queue *queue = &icsk->icsk_accept_queue;

    max_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries;
    thresh = max_retries;

    defer_accept = READ_ONCE(queue->rskq_defer_accept);
    if (defer_accept)
        max_retries = defer_accept;
    syn_ack_recalc(req, thresh, max_retries, defer_accept, &expire, &resend);

    if (!expire && (!resend || !inet_rtx_syn_ack(sk_listener, req) || inet_rsk(req)->acked)) {

        if (req->num_timeout++ == 0)
            atomic_dec(&queue->young);
        timeo = min(TCP_TIMEOUT_INIT << req->num_timeout, TCP_RTO_MAX);
        mod_timer(&req->rsk_timer, jiffies + timeo);
        return;
    }
drop:
    inet_csk_reqsk_queue_drop_and_put(sk_listener, req);
}

关键判断函数syn_ack_recalc,根据重传次数阈值、延迟ACCEPT次数等参数来确定是否过期以及是否重新发送SYN+ACK报文。如果当前的超时重传次数num_timeout已经大于等于阈值,并且还未接收到对端ACK确认报文,内核认为此连接已失败置位expire。或者即使接收到了ACK报文,但是重传次数已经大于等于最大的重传次数max_retries,内核也认为此连接已失败置位expire变量。

如果为接收到对端的ACK确认报文(acked为零),或者当前的超时重传次数与延迟ACCEPT次数仅相差1次时,置位resend变量重新发送SYN+ACK报文。后一判断条件可为对端建立TCP连接提供保障。

如果expire为真,超时处理函数reqsk_timer_handler将消耗此连接(实际上连接还未真正建立)。否则,如果置位了resend变量,内核使用inet_rtx_syn_ack函数执行SYN+ACK报文的重传。下一次的超时时间设置为初始超时时长TCP_TIMEOUT_INIT左移当前超时次数得到的值,但是不超过最大的超出时长TCP_RTO_MAX。

/* Decide when to expire the request and when to resend SYN-ACK */
static inline void syn_ack_recalc(struct request_sock *req, const int thresh, const int max_retries, const u8 rskq_defer_accept,
                  int *expire, int *resend)
{
    *expire = req->num_timeout >= thresh && (!inet_rsk(req)->acked || req->num_timeout >= max_retries);
    /*
     * Do not resend while waiting for data after ACK, start to resend on end of deferring period to give
     * last chance for data or ACK to create established socket.
     */
    *resend = !inet_rsk(req)->acked || req->num_timeout >= rskq_defer_accept - 1;
}

 

客户端检查


TCP客户端接收到服务端回复的SYN+ACK报文之后,进入函数tcp_rcv_synsent_state_process的处理逻辑。如果当前套接口有数据等待发送,或者开启了延迟ACCEPT功能,或者ACK策略设置为pingpong模式,客户端不会立即回复ACK确认报文。对于第一种情况,客户端尝试将数据与ACK一同发送,可减少一次报文发送。但是ACK的延迟时长不能超过TCP_DELACK_MAX定义的时长(200毫秒),如果超时之后,由ACK超时处理函数tcp_delack_timer负责ACK的发送。

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

    if (th->ack) {
        if (!th->syn)
            goto discard_and_undo;

        if (sk->sk_write_pending || icsk->icsk_accept_queue.rskq_defer_accept || icsk->icsk_ack.pingpong) {
            inet_csk_schedule_ack(sk);
            tcp_enter_quickack_mode(sk);
            inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, TCP_DELACK_MAX, TCP_RTO_MAX);
discard:
            tcp_drop(sk, skb);
            return 0;
        } else {
            tcp_send_ack(sk);
        }
        return -1;
    }
}
#define TCP_DELACK_MAX  ((unsigned)(HZ/5))  /* maximal time to delay before sending an ACK */

 

内核版本 4.15

 

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

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

抵扣说明:

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

余额充值