首页 > 系统相关 >[转帖]从Linux源码看TIME_WAIT状态的持续时间

[转帖]从Linux源码看TIME_WAIT状态的持续时间

时间：2024-01-11 13:45:57浏览次数：31  
标签：slot tw Linux tcp 转帖 源码 TIME twdr WAIT 

https://zhuanlan.zhihu.com/p/286537295

 

从Linux源码看TIME_WAIT状态的持续时间

前言

笔者一直以为在Linux下TIME_WAIT状态的Socket持续状态是60s左右。线上实际却存在TIME_WAIT超过100s的Socket。由于这牵涉到最近出现的一个复杂Bug的分析。所以，笔者就去Linux源码里面，一探究竟。

首先介绍下Linux环境

TIME_WAIT这个参数通常和五元组重用扯上关系。在这里，笔者先给出机器的内核参数设置，以免和其它问题相混淆。

cat /proc/sys/net/ipv4/tcp_tw_reuse 0
cat /proc/sys/net/ipv4/tcp_tw_recycle 0
cat /proc/sys/net/ipv4/tcp_timestamps 1

可以看到，我们设置了tcp_tw_recycle为0,这可以避免NAT下tcp_tw_recycle和tcp_timestamps同时开启导致的问题。具体问题可以看笔者的以往博客。

https://my.oschina.net/alchemystar/blog/3119992

TIME_WAIT状态转移图

提到Socket的TIME_WAIT状态，不得就不亮出TCP状态转移图了:


持续时间就如图中所示的2MSL。但图中并没有指出2MSL到底是多长时间，但笔者从Linux源码里面翻到了下面这个宏定义。

#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
                  * state, about 60 seconds    */

如英文字面意思所示，60s后销毁TIME_WAIT状态，那么2MSL肯定就是60s喽？

持续时间真如TCP_TIMEWAIT_LEN所定义么?

笔者之前一直是相信60秒TIME_WAIT状态的socket就能够被Kernel回收的。甚至笔者自己做实验telnet一个端口号，人为制造TIME_WAIT，自己计时，也是60s左右即可回收。


但在追查一个问题时候，发现，TIME_WAIT有时候能够持续到111s,不然完全无法解释问题的现象。这就逼得笔者不得不推翻自己的结论，重新细细阅读内核对于TIME_WAIT状态处理的源码。当然，这个追查的问题也会写成博客分享出来，敬请期待^_^。

TIME_WAIT定时器源码

谈到TIME_WAIT何时能够被回收，不得不谈到TIME_WAIT定时器,这个就是专门用来销毁到期的TIME_WAIT Socket的。而每一个Socket进入TIME_WAIT时，必然会经过下面的代码分支:

tcp_v4_rcv
    |->tcp_timewait_state_process
        /* 将time_wait状态的socket链入时间轮
        |->inet_twsk_schedule

由于我们的kernel并没有开启tcp_tw_recycle,所以最终的调用为:

/* 这边TCP_TIMEWAIT_LEN 60 * HZ */
inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
                     TCP_TIMEWAIT_LEN);

好了，让我们按下这个核心函数吧。

inet_twsk_schedule

在阅读源码前，先看下大致的处理流程。Linux内核是通过时间轮来处理到期的TIME_WAIT socket，如下图所示:


内核将60s的时间分为8个slot(INET_TWDR_RECYCLE_SLOTS),每个slot处理7.5(60/8)范围time_wait状态的socket。

void inet_twsk_schedule(struct inet_timewait_sock *tw,struct inet_timewait_death_row *twdr,const int timeo, const int timewait_len)
{
    ......
    // 计算时间轮的slot
    slot = (timeo + (1 << INET_TWDR_RECYCLE_TICK) - 1) >> INET_TWDR_RECYCLE_TICK;
    ......
    // 慢时间轮的逻辑，由于没有开启TCP\_TW\_RECYCLE,timeo总是60*HZ(60s)
    // 所有都走slow_timer逻辑 
    if (slot >= INET_TWDR_RECYCLE_SLOTS) {
        /* Schedule to slow timer */
        if (timeo >= timewait_len) {
            slot = INET_TWDR_TWKILL_SLOTS - 1;
        } else {
            slot = DIV_ROUND_UP(timeo, twdr->period);
            if (slot >= INET_TWDR_TWKILL_SLOTS)
                slot = INET_TWDR_TWKILL_SLOTS - 1;
        }
        tw->tw_ttd = jiffies + timeo;
        // twdr->slot当前正在处理的slot
        // 在TIME_WAIT_LEN下，这个逻辑一般7
        slot = (twdr->slot + slot) & (INET_TWDR_TWKILL_SLOTS - 1);
        list = &twdr->cells[slot];
    } else{
        // 走短时间定时器，由于篇幅原因，不在这里赘述
        ......
    }
    ......
    /* twdr->period 60/8=7.5 */
    if (twdr->tw_count++ == 0)
        mod_timer(&twdr->tw_timer, jiffies + twdr->period);
    spin_unlock(&twdr->death_lock);
}

从源码中可以看到，由于我们传入的timeout皆为TCP_TIMEWAIT_LEN。所以，每次刚成为的TIME_WAIT状态的socket即将链接到当前处理slot最远的slot(+7)以便处理。如下图所示:


如果Kernel不停的产生TIME_WAIT,那么整个slow timer时间轮就会如下图所示:


所有的slot全部挂满了TIME_WAIT状态的Socket。

具体的清理函数

每次调用inet_twsk_schedule时候传入的处理函数都是:

/*参数中的tcp_death_row即为承载时间轮处理函数的结构体*/
inet_twsk_schedule(tw,&tcp_death_row,TCP_TIMEWAIT_LEN,TCP_TIMEWAIT_LEN)
/* 具体的处理结构体 */
struct inet_timewait_death_row tcp_death_row = {
    ......
    /* slow_timer时间轮处理函数 */
    .tw_timer    = TIMER_INITIALIZER(inet_twdr_hangman, 0,
                        (unsigned long)&tcp_death_row),
    /* slow_timer时间轮辅助处理函数*/
    .twkill_work    = __WORK_INITIALIZER(tcp_death_row.twkill_work,
                         inet_twdr_twkill_work),
    /* 短时间轮处理函数 */
    .twcal_timer    = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0,
                        (unsigned long)&tcp_death_row),                
};

由于我们这边主要考虑的是设置为TCP_TIMEWAIT_LEN(60s)的处理时间，所以直接考察slow_timer时间轮处理函数，也就是inet_twdr_hangman。这个函数还是比较简短的:

void inet_twdr_hangman(unsigned long data)
{
    struct inet_timewait_death_row *twdr;
    unsigned int need_timer;

    twdr = (struct inet_timewait_death_row *)data;
    spin_lock(&twdr->death_lock);

    if (twdr->tw_count == 0)
        goto out;

    need_timer = 0;
    // 如果此slot处理的time_wait socket已经达到了100个，且还没处理完
    if (inet_twdr_do_twkill_work(twdr, twdr->slot)) {
        twdr->thread_slots |= (1 << twdr->slot);
        // 将余下的任务交给work queue处理
        schedule_work(&twdr->twkill_work);
        need_timer = 1;
    } else {
        /* We purged the entire slot, anything left?  */
        // 判断是否还需要继续处理
        if (twdr->tw_count)
            need_timer = 1;
        // 如果当前slot处理完了，才跳转到下一个slot
        twdr->slot = ((twdr->slot + 1) & (INET_TWDR_TWKILL_SLOTS - 1));
    }
    // 如果还需要继续处理，则在7.5s后再运行此函数
    if (need_timer)
        mod_timer(&twdr->tw_timer, jiffies + twdr->period);
out:
    spin_unlock(&twdr->death_lock);
}

虽然简单，但这个函数里面有不少细节。第一个细节，就在inet_twdr_do_twkill_work,为了防止这个slot的time_wait过多，卡住当前的流程，其会在处理完100个time_wait socket之后就回返回。这个slot余下的time_wait会交给Kernel的work_queue机制去处理。


值得注意的是。由于在这个slow_timer时间轮判断里面，根本不判断精确时间，直接全部删除。所以轮到某个slot,例如到了52.5-60s这个slot，直接清理52.5-60s的所有time_wait。即使time_wait还没有到60s也是如此。而小时间轮(tw_cal)会精确的判定时间,由于篇幅原因，就不在这里细讲了。

注: 小时间轮(tw\_cal)在tcp\_tw\_recycle开启的情况下会使用

先作出一个假设

我们假设，一个时间轮的数据最多能在一个slot间隔时间，也就是(60/8=7.5)内肯定能处理完毕。由于系统有tcp_tw_max_buckets设置,如果设置的比较合理,这个假设还是比较靠谱的。

注: 这里的60/8为什么需要精确到小数，而不是7。
因为实际计算的时候是拿60*HZ进行计算，
如果HZ是1024的话，那么period应该是7680,即精度精确到ms级。
所以在本文中计算的时候需要精确到小数。

如果一个slot中的TIME_WAIT<=100

如果一个slot的TIME_WAIT<=100,很自然的，我们的处理函数并不会启用work_queue。同时，还将slot+1,使得在下一个period的时候可以处理下一个slot。如下图所示:

 

如果一个slot中的TIME_WAIT>100

如果一个slot的TIME_WAIT>100,Kernel会将余下的任务交给work_queue处理。同时，slot不变！也即是说，下一个period(7.5s后)到达的时候，还会处理同样的slot。按照我们的假设，这时候slot已经处理完毕，那么在第7.5s的时候才将slot向前推进。也就是说，假设slot一开始为0，到真正处理slot 1需要15s!


假设每一个slot的TIME_WAIT都>100的话，那么每个slot的处理都需要15s。

对于这种情况，笔者写了个程序进行模拟。

public class TimeWaitSimulator {

    public static void main(String[] args) {
        double delta = (60) * 1.0 / 8;

        // 0表示开始清理，1表示清理完毕
        // 清理完毕之后slot向前推进
        int startPurge = 0;
        double sum = 0;
        int slot = 0;
        while (slot < 8) {
            if (startPurge == 0) {
                sum += delta;
                startPurge = 1;
                if (slot == 7) {
                    // 因为假设进入work_queue之后，很快就会清理完
                    // 所以在slot为7的时候并不需要等最后的那个purge过程7.5s
                    System.out.println("slot " + slot + " has reach the last " + sum);
                    break;
                }
            }
            if (startPurge == 1) {
                sum += delta;
                startPurge = 0;
                System.out.println("slot " + "move to next at time " + sum);
                // 清理完之后，slot才应该向前推进
                slot++;
            }
        }
    }
}

得出结果如下面所示:

slot move to next at time 15.0
slot move to next at time 30.0
slot move to next at time 45.0
slot move to next at time 60.0
slot move to next at time 75.0
slot move to next at time 90.0
slot move to next at time 105.0
slot 7 has reach the last  112.5

也即处理到52.5-60s这个时间轮的时候，其实外面时间已经过去了112.5s，处理已经完全滞后了。不过由于TIME_WAIT状态下的Socket(inet_timewait_sock)所占用内存很少，所以不会对系统可用资源造成太大的影响。但是，这会在NAT环境下造成一个坑，这也是笔者文章前面提到过的Bug。
上面的计算如果按照图和时间线画出来，应该是这么个情况:


也即TIME_WAIT状态的Socket在一个period(7.5s)内能处理完当前slot的情况下，最多能够存在112.5s!

如果7.5s内还处理不完，那么响应时间轮的轮转还得继续加上一个或多个perod。但在tcp_tw_max_buckets的限制，应该无法达到这么严苛的条件。

PAWS(Protection Against Wrapped Sequences)使得TIME_WAIT延长

事实上，以上结论还是不够严谨。TIME_WAIT时间还可以继续延长！看下这段源码:

enum tcp_tw_status
tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
               const struct tcphdr *th)
{
    ......
    if (paws_reject)
        NET_INC_STATS_BH(twsk_net(tw), LINUX_MIB_PAWSESTABREJECTED);

    if (!th->rst) {
        /* In this case we must reset the TIMEWAIT timer.
         *
         * If it is ACKless SYN it may be both old duplicate
         * and new good SYN with random sequence number <rcv_nxt.
         * Do not reschedule in the last case.
         */
        /* 如果有回绕校验失败的包到达的情况下,或者其实ack包 
         * 重置定时器到新的60s之后
         * /
        if (paws_reject || th->ack)
            inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
                       TCP_TIMEWAIT_LEN);

        /* Send ACK. Note, we do not put the bucket,
         * it will be released by caller.
         */
        /* 向对端发送当前time wait状态应该返回的ACK */
        return TCP_TW_ACK;
    }
    inet_twsk_put(tw);
    /* 注意，这边通过paws校验的包，会返回tcp_tw_success,使得time_wait状态的
     * socket五元组也可以三次握手成功重新复用
     * /
    return TCP_TW_SUCCESS;
}

上面的逻辑如下图所示:


注意代码最后的return TCP_TW_SUCCESS,通过PAWS校验的包，会返回TCP_TW_SUCCESS,使得TIME_WAIT状态的Socket(五元组)也可以三次握手成功重新复用！
这段逻辑很微妙，会在笔者下一篇<<解Bug之路>>里面进行详解！

总结

如果不仔细分析就下定结论，很容就被自己之前先入为主的一些不够严谨的结论所困扰。导致排查一些复杂问题的时候将思路引导向错误的方向。笔者在追查某个问题的时候就犯了这样的错误。当种种猜测都和事实矛盾时，必须怀疑起自己之前笃定的结论并尝试着推翻它,整个过程即艰辛又快乐！

标签：slot,tw,Linux,tcp,转帖,源码,TIME,twdr,WAIT
From： https://www.cnblogs.com/jinanxiaolaohu/p/17958409

相关文章

  • linux环境编译 TPC-H tools
    上传压缩包复制修改makefile文件make-fmakefile可以看到dbgen和qgen是新生成的......
  • 在Linux Docker中部署RStudio Server，实现高效远程访问
    在LinuxDocker中部署RStudioServer，实现高效远程访问  ......
  • 开源云原生网关Linux Traefik本地部署结合内网穿透远程访问
     开源云原生网关LinuxTraefik本地部署结合内网穿透远程访问前言Træfɪk是一个云原生的新型的HTTP反向代理、负载均衡软件，能轻易的部署微服务。它支持多种后端(Docker,Swarm,Mesos/Marathon,Consul,Etcd,Zookeeper,BoltDB,RestAPI,file…),可以对配置进行......
  • linux之信号操作（九千字长文详解）
    linux之信号操作sigset_t这是信号在内核中的表示==block和pending都是位图——即用bit位来表示信号编号！==每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用==相同的数据类型sigset_t==来存储,==sigset_t......
  • 药品不良反应智能监测系统源码
    java药品不良反应智能监测系统系统概述：   基于AI技术和深度学习模型，系统构建ADR智能识别模型，实现病程记录分析，提取病程记录实体，并完成语义关系的分类识别。一方面可以根据医务人员设置的监测任务或主题，如科室、人群、药品、ADR等，对ADR事件进行智能监测；另一方面也可以根据不良......
  • [转帖]修改Linux内核参数，减少TCP连接中的TIME-WAIT
    https://www.cnblogs.com/xiaoleiel/p/8340346.html 一台服务器CPU和内存资源额定有限的情况下，如何提高服务器的性能是作为系统运维的重要工作。要提高Linux系统下的负载能力，当网站发展起来之后，web连接数过多的问题就会日益明显。在节省成本的情况下，可以考虑修改Linux的内......
  • 基于微信小程序的毕业设计-图书推荐系统(附源码+论文)
    了解设计+图片上号摘要：随着互联网的普及和信息技术的发展，图书推荐管理系统在图书馆中发挥着越来越重要的作用。本文基于SpringBoot框架，设计并实现了一个图书推荐管理系统。该系统能够根据用户的历史阅读记录和兴趣，为其推荐合适的图书，提高图书馆的借阅率。关键词：微信小程序；图书推荐；......
  • linux网络磁盘映射到windows
    在linux中按照以下步骤执行第一步：安装samba套件：sudoapt-getinstallsambasudoapt-getinstallsmbclient第二步：修改配置文件：sudovim/etc/samba/smb.conf第三步：添加参数设置：​ 可以在末尾添加[zxc]comment=VMwareUbuntuSharepath=/home/zxc/data......
  • 【设计模式】模板方法模式——模板方法模式在JDK源码中的应用
    模板方法模式在JDK源码里最典型的实现就是AQSAbstractQueuedSynchronizerAQS(AbstractQueuedSynchronizer)的部分代码如下：publicabstractclassAbstractQueuedSynchronizerextendsAbstractOwnableSynchronizerimplementsjava.io.Serializable{//……代码......
  • ? 开源即时通讯（IM）项目OpenIM源码部署指南
    OpenIM的部署涉及多个组件，并支持多种方式，包括源码、Docker和Kubernetes等。这要求在确保不同部署方式之间的兼容性同时，还需有效管理各版本之间的差异。确实，这些都是复杂的问题，涉及到深入的技术细节和精准的系统配置。我们的目标是简化部署流程，同时保持系统的灵活性和稳定性，以适应不......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99