TCP · XB 现场笔记

TCP backlog 收纳还在握手中的连接

Fri, 24 Mar 2028 00:00:00 +0000

一个监听中的 TCP 套接字有两个队列，不是一个；而本文标题里那个 sysctl 管的，恰恰是几乎从不丢东西的那一个。传给 listen(2) 的 backlog 是 accept 队列，装的是已经完成握手、正等应用来取走的连接；SYN 队列装的才是半开请求。把两者混为一谈，就会开错药方。

这件事值得掰开，因为那句著名的建议——把 tcp_max_syn_backlog 调大——基本已经过时。tcp_syncookies 默认就是 1，而按 listen(2) 的说法，一旦启用 syncookies，SYN 队列就没有逻辑上的长度上限，这个设置会被忽略。真正会卡住你的是 accept 队列，以及应用调用 accept() 的速度。

backlog 参数管的是 accept 队列

listen(2) 明确写着，这个行为在 Linux 2.2 就变了：backlog 现在指的是「已完成建立、正等待被 accept 的套接字队列长度」，而不是半开请求的数量。半开队列由 /proc/sys/net/ipv4/tcp_max_syn_backlog 单独限制。而如果 backlog 参数超过 /proc/sys/net/core/somaxconn，它会被静默截断到那个值——Linux 5.4 之后是 4096，之前是 128。所以在默认配置的机器上写 listen(8192)，实际拿到的是 4096，而且不会有任何日志告诉你。

tcp(7) 把 tcp_max_syn_backlog 描述为「尚未收到对端确认的排队连接请求上限」：默认 256，内存达到 128 MB 及以上时升到 1024，低于 32 MB 时降到 128。ip-sysctl 补上了真正重要的限定：它是 per-listener 的限制，每个半开请求套接字大约占 304 字节，而 tcp_syncookies 默认为 1——队列溢出时发一个 cookie，而不是把请求丢掉。

syncookies 开着的时候，SYN 队列就不再是瓶颈

ip-sysctl 把 tcp_syncookies 记录为一种兜底手段，并明确说不能用它去帮一台高负载服务器扛合法的连接吞吐；它还指出 syncookies 严重违反 TCP 协议、无法使用 TCP 扩展，并可能让某些服务明显劣化。listen(2) 更进一步：启用 syncookies 时没有逻辑上的长度上限，tcp_max_syn_backlog 被忽略。而 tcp(7) 仍然把同一个旋钮描述为「超过就开始丢弃请求」——那是 syncookies 关掉时的行为。两页手册各自都说对了，只是说的是不同配置。另外 ip-sysctl 注明，syncookies 只在编译时启用了 CONFIG_SYN_COOKIES 的内核上有效，所以它并不是一个必然存在的兜底。

所以诚实的结论是：让 syncookies 保持 1，别再折腾 SYN 队列。代价是这条兜底路径救回来的连接会失去窗口缩放、SACK 这类 TCP 扩展，属于吞吐问题而不是连通性问题。如果你在合法流量下看到 SYN flood 告警，ip-sysctl 自己的建议是去调别的旋钮，而不是关掉 syncookies。

压力真正落在 accept 队列上

SYN 队列被中和之后，会满的是 accept 队列，它的容量是 min(listen(backlog), somaxconn)。溢出时的行为取决于 tcp_abort_on_overflow，默认是 FALSE：ip-sysctl 说默认值意味着「如果溢出只是突发造成的，连接会恢复」，并警告打开这个开关会伤害你的客户端。机制才是意外之处：默认情况下内核会静默丢弃最后一个 ACK，于是客户端的 connect() 成功返回，故障要等到第一个请求卡住或被重置时才浮现。之所以说默认值「能恢复」，是因为服务端随后还会按自己的节奏重传 SYN-ACK：只要在它放弃之前队列里腾出位置，这条连接就能被救回来。这也正是它无声的原因——客户端那边从头到尾都认为自己已经连上了。

更大的 backlog 是延迟线，不是容量。在模型里，listen(128) 和 listen(65535) 一秒内 accept 的连接数完全一样，都是 20,000；更大的队列只是把溢出的时刻往后推，因为 accept 速率由 worker 数量决定。

坏掉的样子

第一种故障是无声的那种，而且它就是默认行为。accept 循环太慢的服务会把 accept 队列挤满，内核丢掉最后的 ACK，客户端看到的是「连接建立了，然后就挂着」。没有任何东西被拒绝，于是客户端的连接池里堆满死套接字，报错最终出现在一个看起来无关的层面。盯住 TcpExtListenOverflows 和 TcpExtListenDrops：这两个计数器上涨而 accept 速率平稳，说明瓶颈在处理线程。

第二种故障是被丢弃的 SYN，只有在 syncookies 关掉时才会发生。SYN 队列满了就丢请求，客户端按重传时间表重试，文档给出的两个端点是「最后一次重传到 67 秒、最终超时到 131 秒」，所以用户看到的现象是一次挂了两分多钟才失败的连接。在这种配置下调大 tcp_max_syn_backlog 是真正的修法，而把 syncookies 重新打开是更好的修法——前提是你接受 TCP 扩展的损失。

快速验证

ss -lnt 'sport = :8443'
nstat -az TcpExtListenOverflows TcpExtListenDrops TcpExtTCPReqQFullDrop TcpExtTCPReqQFullDoCookies
sysctl net.core.somaxconn net.ipv4.tcp_max_syn_backlog net.ipv4.tcp_syncookies net.ipv4.tcp_abort_on_overflow

在 ss -lnt 里，Send-Q 是这个套接字创建时的 backlog，Recv-Q 是已经建立但还没被 accept 的连接数；Recv-Q 顶到 Send-Q 就是队列满了。nstat 的几个计数器应该为零或接近零：TcpExtListenOverflows 和 TcpExtListenDrops 属于 accept 队列事件，TcpExtTCPReqQFullDrop 是被丢掉的 SYN，TcpExtTCPReqQFullDoCookies 则是兜底机制在正常工作。sysctl 那一行显示内核真正会认的数字——如果 somaxconn 比你的 listen() 参数小，那么那个更小的值才是你真实的 backlog。

来源

内核 ip-sysctl 文档，somaxconn、tcp_max_syn_backlog、tcp_abort_on_overflow 以及 syncookies 的警告，已核验 2026-09-16。
Linux listen(2)，Linux 2.2 起的 accept 队列、somaxconn 的静默截断，以及 syncookies 如何取消 SYN 队列上限，已核验 2026-09-16。
Linux tcp(7)，tcp_max_syn_backlog 按内存大小的默认值，以及 syncookies 的注意事项，已核验 2026-09-16。

TCP 慢启动随数据确认增长，不会仅因时间流逝而翻倍

Tue, 28 Dec 2027 00:00:00 +0000

慢启动在 TCP 发送端探索路径可承受的未确认数据量时，逐步扩大拥塞窗口。数据充足且确认模式合适时，经典行为是在多个往返间近似指数增长。“每个 RTT 翻倍”是有用的简化模式，不是无条件计时器规则。窗口变化依赖传输反馈和实现的增长条件，不能只根据连接已经打开多久，就推断它获得了多少发送预算。

坏掉的样子

connect 之后等待，不会自动把拥塞窗口预热。应用没有发送数据时，就没有支持这种增长的数据确认。很小的交换，也可能在用满已有发送预算之前便结束。期待每个短请求都出现大幅翻倍序列，是把受应用数据量限制的传输误认成持续积压的发送端。缺少明显增长，并不自动说明慢启动没有工作或连接存在故障。

现代系统初始窗口也不统一为一到两个段。RFC 6928 描述了允许更大初始窗口的实验性扩展，本次 Linux 发送端起步为十个段。单位同样重要：Linux TCP_INFO 的 snd_cwnd 以段为单位，许多协议说明则用字节描述拥塞窗口。推算未确认数据量之前，应同时查看发送 MSS，避免将段数直接当成字节数或当前实际在途段数。

慢启动并非总要持续到第一次丢失，之后统一彻底缩回起点。慢启动阈值帮助决定启动增长与拥塞避免，具体实现还可能采用额外启动检测；重传超时恢复也不同于快速恢复。把同一条示意曲线套到所有算法、丢失信号和工作负载，即使读到了真实指标，也可能作出错误诊断。首先需要确认当前连接处于哪个阶段。

快速验证

将脚本保存为 check-slow-start.py，准备 Docker 后运行 python3 check-slow-start.py。一次性环境使用 Python 3.11.16 和 iproute2 6.1.0，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间。客户端和目标通过新建 veth 相连，netem 在两个方向的出口各添加十毫秒延迟，全部变更仅作用于虚拟端点：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


info_code=r'''
import struct
def tcp_info(stream):
 raw=stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_INFO,104);assert len(raw)==104
 offsets={'snd_mss':16,'unacked':24,'rtt_us':68,'snd_ssthresh':76,'snd_cwnd':80,'total_retrans':100}
 return {'ca_state':raw[1],**{key:struct.unpack_from('=I',raw,offset)[0] for key,offset in offsets.items()}}
'''
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 for name,interface in [('client','c0'),('target','t0')]:
 ns(name,'tc','qdisc','add','dev',interface,'root','netem','delay','10ms','limit','10000')
 server_code=r'''
import socket,json,hashlib,sys
size=int(sys.argv[1]);listener=socket.socket();listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
with listener.accept()[0] as connection:
 connection.settimeout(6);remaining=size;digest=hashlib.sha256()
 while remaining:
 chunk=connection.recv(min(65536,remaining));assert chunk;remaining-=len(chunk);digest.update(chunk)
 assert digest.hexdigest()==hashlib.sha256(b'x'*size).hexdigest()
 connection.sendall((digest.hexdigest()+'\n').encode())
'''
 client_code=info_code+r'''
import socket,json,time,threading,sys,hashlib
size=int(sys.argv[1]);stream=socket.socket();stream.settimeout(6)
stream.setsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,b'reno');stream.connect(('192.0.2.2',18080))
initial=tcp_info(stream);time.sleep(.06);idle=tcp_info(stream);assert idle['snd_cwnd']==initial['snd_cwnd']
done=threading.Event();errors=[];samples=[initial,idle];reply=[]
def transfer():
 try:
 stream.sendall(b'x'*size)
 with stream.makefile('rb') as incoming:reply.append(incoming.readline().decode().strip())
 except BaseException as error:errors.append(repr(error))
 finally:done.set()
worker=threading.Thread(target=transfer);worker.start();deadline=time.monotonic()+7
while not done.wait(.005):
 assert time.monotonic()<deadline,'transfer deadline exceeded'
 snapshot=tcp_info(stream)
 if snapshot!=samples[-1]:samples.append(snapshot)
worker.join(timeout=1);assert not worker.is_alive() and not errors,errors
samples.append(tcp_info(stream));assert reply==[hashlib.sha256(b'x'*size).hexdigest()]
assert all(row['total_retrans']==0 for row in samples),samples
if size>1:assert max(row['snd_cwnd'] for row in samples)>initial['snd_cwnd']*2,samples
else:assert max(row['snd_cwnd'] for row in samples)==initial['snd_cwnd'],samples
print(json.dumps({'bytes':size,'algorithm':stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,16).split(b'\0')[0].decode(),
 'before_data':initial,'after_idle_without_data':idle,'samples':samples,'sha256':reply[0]}));stream.close()
'''
 results={}
 for label,size in [('short',1),('bulk',1048576)]:
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code,str(size)]);assert line(service).strip()=='listening'
 results[label]=json.loads(ns('client','python3','-c',client_code,str(size),timeout=10).stdout)
 service.wait(timeout=2);assert service.returncode==0
 print(json.dumps({'egress_delay_each_direction_ms':10,'transfers':results}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

客户端明确选择 Reno，避免实验悄悄受不同默认拥塞控制器影响。发送之前记录 TCP_INFO，在没有数据的情况下等待六十毫秒，然后再次记录。两次观察窗口均为十个段。这直接检验“新连接只要保持打开，拥塞预算就会按时间增长”的错误预期。增加等待时间与提供可确认的数据，属于不同输入，不能互相替代。

第一次传输发送一个字节，并接收服务器返回的摘要。采样中未确认段数先为一、随后为零，拥塞窗口始终保持十。这个负载成功交付，并不需要可见的指数增长，因为原先允许的在途量已足以容纳整个请求。应用提供的数据太少，没有驱动大流量启动爬升；不能从这种短小成功交换里期待完整带宽探测曲线。

第二次发送一 MiB。独立线程执行阻塞交换，主线程持续采样套接字状态，避免 sendall 等待期间丢失观察。记录包含十、二十、四十、八十个段，随后随着确认聚合和传输进展出现不那么整齐的数值。测试要求窗口显著增长，没有规定唯一采样序列，也不假定每个样本恰好对应一个 RTT。具体数值需要连同采样方法解释。

服务器与客户端通过 SHA-256 验证载荷，所有采样的累计重传数保持零。本次阈值远高于观察到的窗口。这些事实支持由确认驱动的启动演示，但没有刻意验证丢失恢复，也没有测量共享瓶颈。人工添加的延迟使过程容易观察，不代表真实广域网容量或公平性。读者不能把隔离虚拟链路当作生产网络性能基准。

结合负载解释增长轨迹

一起记录算法、MSS、拥塞窗口、阈值、未确认数据、RTT 与重传证据。窗口大于当前未确认段数完全可能，因为应用或接收端还会施加其他限制。采样窗口代表发送端当前允许量，不保证路径上始终存在恰好那么多段。把预算与实际占用区分开，才能判断停顿来自拥塞控制、数据不足还是接收方向约束。

采样本身也影响图景。用户态观察者可能错过中间变化，五毫秒间隔并未与 ACK 到达同步。延迟确认、卸载行为和调度都会改变可见序列。脚本检查数据能够支持的关系，不会仅因少了某个中间值，就宣称拥塞控制器损坏。判断异常之前，应先确认观测精度是否足以支持所期待的逐步变化。

对短操作，在应用协议允许时减少无谓的新连接，可以避免反复使用全新的拥塞预算。连接复用后，空闲重启策略仍可能减小窗口，不能保证此前形成的发送预算一直保留。对批量传输，修改启动设置之前应测试代表性 RTT、丢失、接收行为和竞争流量。本例把空闲时间、微小成功交换与持续数据区分开，为判断慢启动是否与观察到的延迟有关提供具体依据。优化需要针对真实约束，而不是只追求曲线看起来翻倍整齐。

来源

RFC 5681 Congestion Control，由确认驱动的慢启动、拥塞避免、阈值切换与空闲重启，已核验 2026-09-12。
RFC 6928 Initial Window，允许更大初始拥塞窗口的实验性扩展，已核验 2026-09-12。
Linux 6.12.76 TCP_INFO fields，拥塞窗口、阈值、未确认段与重传字段，已核验 2026-09-12。

TCP 窗口缩放分别扩展两个方向的接收窗口编码

Thu, 02 Dec 2027 00:00:00 +0000

TCP 头部的接收窗口字段只有十六位。窗口缩放让已建立连接依据握手期间确定的移位解释这个字段，从而允许接收端通告超过65535字节的空间。两个方向可以采用不同移位值。它扩展的是接收窗口信息的编码，不会直接扩大每个缓冲区，也不保证发送端始终让那么多数据处于未确认状态。

坏掉的样子

高带宽且 RTT 较长的路径，可能需要远多于未缩放窗口所能描述的在途数据。例如每秒一百兆比特、往返八十毫秒，对应大约一百万字节在途数据；65535字节窗口会形成明显更低的理想速率上限。带宽时延积用于容量估算，不是吞吐量实测，也不保证链路不存在其他约束，不能用一个乘法直接宣布应用应达到某个速度。

发送端还受到拥塞窗口限制，并且必须有应用数据可发。扩大接收窗口编码，无法修复过小的拥塞预算、停止读取的应用、丢包或被阻断的路由。零窗口经过缩放仍然是零。应判断究竟哪个资源限制进展，不能仅因握手里存在缩放选项，就断言连接理应跑满链路，也不能把所有低吞吐问题都归因于缓冲配置。

对协商的误解还会导致抓包解释错误。双方都必须提供选项，缩放才能生效；每个因子用于解释提供它的端点所通告的窗口。SYN 与 SYN-ACK 自身的窗口字段从不缩放。使用反方向的移位值，或把 SYN 窗口也乘上因子，即使数据包字节完全正确，也会算出错误容量。报文值需要结合方向和连接阶段解释。

快速验证

将脚本保存为 check-window-scaling.py，准备 Docker 后运行 python3 check-window-scaling.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间及临时 proc 挂载。端点通过新建 veth 相连，所有设置仅作用于实验范围：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 server_code=r'''
import socket,json
def read_exact(stream,length):
 data=b''
 while len(data)<length:
 chunk=stream.recv(length-len(data));assert chunk,'premature EOF';data+=chunk
 return data
listener=socket.socket();listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
listener.setsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF,262144)
listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
with listener.accept()[0] as connection:
 connection.settimeout(4);print(json.dumps({'rcvbuf':connection.getsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF)}),flush=True)
 assert read_exact(connection,4)==b'ping';connection.sendall(b'pong')
 assert connection.recv(1)==b''
'''
 client_code=r'''
import socket,json,sys
def read_exact(stream,length):
 data=b''
 while len(data)<length:
 chunk=stream.recv(length-len(data));assert chunk,'premature EOF';data+=chunk
 return data
s=socket.socket();s.settimeout(4);s.setsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF,65536)
s.bind(('192.0.2.1',40400+int(sys.argv[1])));s.connect(('192.0.2.2',18080));s.sendall(b'ping')
assert read_exact(s,4)==b'pong'
print(json.dumps({'rcvbuf':s.getsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF),'reply':'pong'}),flush=True)
assert sys.stdin.readline().strip()=='close';s.close()
'''
 outcomes={}
 for enabled in [1,0]:
 setting('client','net.ipv4.tcp_window_scaling',enabled);setting('target','net.ipv4.tcp_window_scaling',enabled)
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='listening'
 tap,path=capture(stack,root,'client','c0','tcp port 18080','window'+str(enabled))
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code,str(enabled)])
 client_result=json.loads(line(client));server_result=json.loads(line(service))
 diagnostics=ns('client','ss','-tin','state','established').stdout
 client.stdin.write('close\n');client.stdin.flush();client.wait(timeout=2);service.wait(timeout=2)
 assert client.returncode==service.returncode==0
 observed=packets(tap,path);syn=next(p for p in observed if p['flags']&0x12==0x02)
 synack=next(p for p in observed if p['flags']&0x12==0x12)
 advertised=next(p for p in observed if p['sport']==18080 and p['length']==4)
 if enabled:
 assert 'wscale' in syn['options'] and 'wscale' in synack['options']
 effective=advertised['window']<<synack['options']['wscale'];assert effective>65535
 else:
 assert 'wscale' not in syn['options'] and 'wscale' not in synack['options'];effective=advertised['window'];assert effective<=65535
 outcomes[enabled]={'client':client_result,'server':server_result,'syn':syn,'synack':synack,
 'server_post_handshake_window_field':advertised['window'],'effective_receive_window':effective,'ss':diagnostics}
 print(json.dumps(outcomes))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

连接建立之前，客户端请求65536字节接收缓冲，服务器监听套接字请求262144字节。脚本读取最终套接字选项值，不假定请求值会原样使用。Linux 的缓冲记账和上限会影响结果，本次客户端报告131072，服务器接受后的套接字报告425984。二者均不能直接等同于线上通告窗口。

两端启用缩放时，捕获到客户端 SYN 提供移位一，服务器 SYN-ACK 提供移位二。初始窗口字段仍按未缩放值解释。建立连接后，服务器数据段的窗口字段为53213，应用服务器因子后乘以四，得到212852字节。客户端套接字诊断也独立报告对应发送窗口，使协商、报文与生效状态互相印证。

下一条全新连接在两端关闭缩放，保持缓冲请求和应用交互相同。两个 SYN 都没有缩放选项，服务器通告窗口为65535字节。两次都发送 ping 并收到 pong，既检查协商，也检查真实通信。对照展示编码限制，没有把四字节交换包装成最大吞吐量测试；应用成功与容量上限属于不同结论。

脚本捕获建立过程，因为缩放因子对该连接固定。之后改变系统默认值，不会重新协商已有字节流。如果接收缓冲行为影响握手选择，就应在 connect 或 listen 前适当配置。从握手之后才开始的抓包，需要补充此前协商状态，才能正确解释原始窗口字段。缺少这段背景时，单看一个较小字段容易误判接收能力。

区分缓冲分配、通告容量与实际性能

记录相关套接字设置、双方移位、当前通告窗口、拥塞窗口、RTT 和应用活动。这些描述不同限制。分配量很大时，通告窗口仍可能较小，因为协议栈要考虑缓冲记账与当前占用。本例有意同时给出分配值和报文值，把差异明确展示出来，避免将多个不同指标都笼统叫作“窗口大小”，导致调参对象错误。

传输未达预期时，检查接收应用是否持续消费，以及发送端是否有足够任务使用允许的在途量。修改缓冲预算之前，应审阅丢包和拥塞行为。大量并发套接字采用更大分配，也会增加资源需求，因此调优应依靠负载证据，而不是把所有上限设到最大。只改变编码能力，无法保证应用生产与消费速度随之提升。

协议将移位限制为十四，使可表示窗口小于一吉比字节。这个编码上限并不要求分配同样多内存。变更之后，应针对部署内核和代表性流量验证。本例检查协商、方向、计算及成功交换，持续容量和实际应用行为还需要适合真实路径的测量。明确区分这些结论，才能避免用一个选项的存在代替完整性能证据。

来源

RFC 7323 TCP Extensions，双向独立缩放因子、SYN 例外与接收窗口计算，已核验 2026-09-12。
Linux tcp(7)，接收缓冲、窗口缩放与建立连接前的套接字设置，已核验 2026-09-12。
RFC 5681 Congestion Control，拥塞窗口与接收窗口分别施加的限制，已核验 2026-09-12。

Nagle 与延迟 ACK 可能让小请求的第二部分等待

Sun, 31 Oct 2027 00:00:00 +0000

Nagle 算法减少 TCP 小报文：当前面数据尚未确认时，它会暂缓额外的小块数据，除非已经积累到足以构成完整段。延迟确认则是接收端的另一种行为，可以短暂推迟 ACK。当应用把一个请求拆成多个很小的写入，而对端必须取得后续字节才能生成响应时，两者的相互作用就会影响延迟。需要明确是哪一部分数据已经发出、哪一部分仍在等待。

坏掉的样子

单独一个小请求，不会自动被 Nagle 延迟。如果没有更早的未确认数据，第一个小段可以直接发送。问题场景是第一部分已在途中，第二个短小部分排在后面等待。如果接收端延迟确认，同时应用又在等完整请求，进展可能暂停，直到确认计时器到期。不能把所有“小请求慢”都归到这个机制，也不能省略前面存在未确认数据这一条件。

这属于有边界的延迟，不是协议无限死锁。ACK 可以释放排队数据，积累足够多数据也可能改变发送决策。观察到的等待既不统一等于额外一个 RTT，也不固定为四十毫秒。接收策略、已有确认状态、请求分帧和网络条件，共同决定真正的报文顺序与时间。把一次实验数值当成所有系统的常数，会误导后续故障判断。

TCP_NODELAY 关闭指定套接字上的 Nagle，却不会关闭所有缓冲、拥塞控制、接收窗口流控或调度延迟。Linux TCP_QUICKACK 请求改变确认模式，但这种模式不是永久设置。把任意一个选项当作万能延迟开关，可能掩盖应用缓冲或其他传输限制；这些问题本来就不在该选项职责内，需要通过对应层次的证据定位。

快速验证

将脚本保存为 check-nagle.py，准备 Docker 后运行 python3 check-nagle.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间。客户端和目标通过新建 veth 通信，所有参数都留在实验范围内，不修改宿主正在使用的网络配置：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 setting('client','net.ipv4.tcp_autocorking',0)
 server_code=r'''
import socket,json
def read_exact(stream,length):
 data=b''
 while len(data)<length:
 chunk=stream.recv(length-len(data));assert chunk,'premature EOF';data+=chunk
 return data
listener=socket.socket();listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
for trial in range(2):
 with listener.accept()[0] as connection:
 connection.settimeout(3);connection.setsockopt(socket.IPPROTO_TCP,socket.TCP_QUICKACK,0)
 print('configured',flush=True)
 request=read_exact(connection,2);assert request==b'ab',request
 connection.sendall(b'OK');print(json.dumps({'request':request.decode()}),flush=True)
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='listening'
 tap,path=capture(stack,root,'client','c0','tcp port 18080','nagle')
 client_code=r'''
import json,socket,sys,time
def read_exact(stream,length):
 data=b''
 while len(data)<length:
 chunk=stream.recv(length-len(data));assert chunk,'premature EOF';data+=chunk
 return data
nodelay=int(sys.argv[1]);s=socket.socket();s.settimeout(3)
s.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,nodelay);s.bind(('192.0.2.1',40300+nodelay));s.connect(('192.0.2.2',18080))
print('connected',flush=True);assert sys.stdin.readline().strip()=='go'
start=time.monotonic();s.sendall(b'a');time.sleep(.002);s.sendall(b'b');reply=read_exact(s,2)
assert reply==b'OK';print(json.dumps({'nodelay':nodelay,'reply':reply.decode(),'elapsed_ms':(time.monotonic()-start)*1000}),flush=True);s.close()
'''
 outcomes=[]
 for nodelay in [0,1]:
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code,str(nodelay)])
 assert line(client).strip()=='connected' and line(service).strip()=='configured'
 client.stdin.write('go\n');client.stdin.flush();outcomes.append(json.loads(line(client)))
 assert json.loads(line(service))['request']=='ab';client.wait(timeout=2);assert client.returncode==0
 observed=packets(tap,path);timelines={}
 for nodelay in [0,1]:
 port=40300+nodelay;flow=[p for p in observed if port in (p['sport'],p['dport'])]
 first=next(p for p in flow if p['sport']==port and p['preview']=='61')
 second=next(p for p in flow if p['sport']==port and p['preview']=='62')
 assert (second['seq']-first['seq'])%2**32==1
 acks=[p for p in flow if p['dport']==port and p['flags']&0x10 and 0<(p['ack']-first['seq'])%2**32<=2]
 assert acks
 if not nodelay:
 intermediate=next(p for p in acks if (p['ack']-first['seq'])%2**32==1)
 assert first['t']<intermediate['t']<=second['t'] and second['t']-first['t']>.01
 else:assert second['t']<=acks[0]['t']
 timelines[nodelay]={'first_byte':first,'second_byte':second,'first_ack_covering_data':acks[0],
 'data_segment_gap_ms':(second['t']-first['t'])*1000}
 print(json.dumps({'trials':outcomes,'packet_timelines':timelines,'receiver_quickack_requested':0,'client_autocorking':0}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

服务器等待完整请求 ab 才回复 OK。每次试验之前，它在已接受连接上请求非快速确认模式。客户端关闭本命名空间自动 corking，以排除另一种合并机制对比较的影响。父子进程通过明确消息同步，确保接收端先完成套接字设置，再让客户端开始发送应用字节，避免把配置时序竞争误认为算法差异。

第一次试验把 TCP_NODELAY 设为零。客户端发送 a，等待两毫秒，再发送 b。这些写入是应用动作，并不保证立即产生分离报文。抓包显示第一个字节离开、覆盖它的 ACK 到达，随后第二个字节才离开。程序检查这个顺序，而不是只要响应变慢就宣称 Nagle 一定是原因。应用写入时间与实际传输时间必须分开观察。

本次记录中，两段数据相隔约四十一毫秒，完整交互也花费接近这个时间。第二次启用 TCP_NODELAY，保持相同分帧与刻意加入的等待。第二个字节在首个数据确认之前离开，两段间隔约两毫秒。服务器在两次试验中都取得完整请求，并返回相同有效回复。比较改变的是传输时机，不能将第一种情况写成请求永远无法完成。

这些时间描述受控运行，不是生产延迟保证。脚本要求在所述设置下看到延迟确认交互，并检查对应报文先后关系；其他内核或接收策略需要重新调查。流式读取明确累积所需字节数，因为 recv 即使给定长度，通常也不保证一次返回完整应用消息。这个边界与 Nagle 是否启用无关，应用必须始终正确处理分段读取。

一起决定请求分帧与套接字策略

对于已经完整存在内存中的小型逻辑请求，可以考虑把完整表示一起写出，避免接收端等后续片段，同时保留有价值的传输合并。必须及时交付独立小更新的交互流，则可能适合 TCP_NODELAY。选择应依据负载的消息边界与实测行为，不能对所有连接使用同一条经验规则，也不能通过改变分帧后忘记重新检查应用语义。

请求周期性停顿时，同时捕获数据和确认，判断第二部分仍停在应用缓冲、已排入发送端，还是已经到达对端。应用中的一个超时，无法区分这些阶段。将抓包与套接字配置、接收端认定请求完整的时刻关联，才能知道需要改变哪一处等待，而不是反复调整与问题没有关系的传输参数。

大量发送微小更新时，还要考虑包速率与带宽开销。减少不必要的合并等待，可以改善交互，却也可能增加每次操作产生的段数。应同时测量相关响应延迟和资源成本。这里有用的结果，是对特定交互建立有证据支持的策略：两次请求都成功，而实际观察到的发送顺序不同，足以解释本例等待差异，但不构成统一性能承诺。

来源

RFC 896 Congestion Control，前面数据未确认时合并小块写入，已核验 2026-09-12。
RFC 1122 Host Requirements，延迟确认行为及其等待边界，已核验 2026-09-12。
Linux tcp(7)，TCP_NODELAY 与 TCP_QUICKACK 的临时性，已核验 2026-09-12。

SYN Cookie 在队列溢出时作答

Sat, 30 Oct 2027 00:00:00 +0000

监听套接字维护的是两个队列，不是一个。半开连接先待在 SYN 队列里，直到客户端的最后一个 ACK 到达；握手完成的连接随后进入 accept 队列，等着应用调用 accept()。两者各有各的上限，而究竟是哪一个溢出，决定了客户端体验到什么。

SYN Cookie 是为第一个队列准备的。它满了以后，服务器不再分配状态，转而把稍后需要的东西编进序号里，于是握手在零内存占用下完成。这确实是一次救援，同时也是一次降级：被救下来的那条连接，比正常情况下本该建立的那条更差。

两个队列，两种症状

一个 SYN 会分配一个 request socket，把连接推进 SYN_RECV 并回一个 SYN-ACK。客户端的 ACK 再把它移进 accept 队列、状态变成 ESTABLISHED。SYN 队列由 tcp_max_syn_backlog 按监听套接字限流——最小值 128，随内存放大，每个表项大约占 304 字节。accept 队列的上限来自 somaxconn（当前内核默认 4096，Linux 5.4 之前是 128），再与应用程序传给 listen() 的 backlog 共同起作用。

两种溢出长得完全不一样。SYN 队列溢出正是 syncookie 为之而生的场景：连接照样能完成。accept 队列溢出更糟也更安静——在 tcp_abort_on_overflow 取默认值 0 的情况下，服务器直接忽略那个最后的 ACK，于是 connect() 返回成功，客户端把请求发出去，然后再也等不到任何回应。实测：backlog 设为 1、客户端 400 个，400 个全都以为自己连上了，服务器实际只能接受 3 个，另外 397 个在两端都没有任何报错的情况下丢掉了。

tcp_syncookies 取默认值 1 时，SYN backlog 一溢出，内核就发 cookie。它不再分配 request socket，而是把初始序号算成「高 8 位放计数器、低 24 位放截断哈希」，哈希覆盖两端地址、两个端口、计数器和一个服务端密钥。计数器每 64 秒前进一格，所以同一个四元组在每一格上算出的 cookie 都不同。

校验过程就是把它倒过来。ACK 的确认号高 8 位带着计数器，服务器拿它和自己的当前格、上一格比对，再按四元组重算哈希并比较低 24 位。复现这套构造的结果是：刚发出的 ACK 校验通过；70 秒后重放的 ACK——也就是往前一格——依然通过；200 秒和 600 秒之后则被判为过期。把源端口或源地址改动一个，立刻被拒，所以 cookie 被绑死在这条连接上，无法搬到别处使用。盲猜的成功概率是 1677 万分之一，整个安全论证就靠这个数字。

带 cookie 的 SYN-ACK 不携带任何选项。内核文档说得毫不客气：syncookie「严重违反 TCP 协议，不允许使用 TCP 扩展，可能导致某些服务严重劣化」。代价最贵的是窗口缩放——没有它，接收窗口上限是 65535 字节，而不是缩放因子 7 下的 8388480 字节。在 100 毫秒的路径上，这就是 5.2 Mbit/s 对 671.1 Mbit/s，128 倍的差距，只因为少了一个选项。SACK 同样没了，于是一个窗口里丢了好几个段的发送方，只能靠累积确认一次恢复一个。

MSS 算是部分救回来了：cookie 路径偷走三个哈希位去索引一张小 MSS 表，而这是唯一活下来的选项。时间戳、SACK、窗口缩放则干脆不存在。所以处于 cookie 模式的服务器不只是少收了几条连接，它收下的那些连接本身是慢的，而这种慢看起来像网络问题，不像握手问题。

坏掉的样子

第一种失败，是 cookie 把真实的洪泛从监控视野里藏了起来。SyncookiesSent 上涨就是信号，但按设计，洪泛在应用层是隐形的：没有半开队列可告警、没有失败连接、没有错误日志，只有一个计数器。建立在错误率或 SYN_RECV 深度上的看板，会在服务器正被持续攻击时显示一切健康。要盯的是 cookie 计数器及其与新建连接数的比值，不是应用本身。

第二种失败，是 accept 队列照样溢出，而 cookie 对此毫无办法。ListenOverflows 上涨，客户端在第一个请求上超时，瓶颈在 accept() 而不在 SYN 队列——实测 400 条里丢掉 397 条，而每个客户端都以为自己连上了。解法是让应用接受得更快、加 worker、抬高 somaxconn 和 listen backlog，而不是去调 syncookie。要记住 cookie 只在 SYN 队列溢出时才启用：瓶颈若在 accept 队列，把它打开或关掉都不会改变任何数字。

快速验证

同时看两个队列和计数器：

sysctl net.ipv4.tcp_syncookies net.ipv4.tcp_max_syn_backlog net.core.somaxconn
nstat -az | grep -E 'Syncookies|ListenOverflow|ListenDrops'
ss -lnt

健康的服务器上三个计数器都读 0，ss -lnt 里的 Send-Q 与配置的 backlog 一致，Recv-Q 为 0。SyncookiesSent 上涨说明 SYN 队列溢出过；ListenOverflows 上涨说明 accept 队列溢出过，而那一个不是 cookie 能修的。如果监听套接字的 Recv-Q 长期大于零，说明已建立的连接正在等一个调用 accept() 不够快的应用。

来源

RFC 4987 TCP SYN 洪泛缓解，cookie 的构造方式及其取舍，已核验 2026-09-16。
RFC 9293 TCP，三次握手与 backlog 的概念，已核验 2026-09-16。
Linux 内核 ip-sysctl，tcp_syncookies、tcp_max_syn_backlog、somaxconn 与 tcp_abort_on_overflow，已核验 2026-09-16。

listen backlog 保存等待 accept 的连接

Mon, 25 Oct 2027 00:00:00 +0000

对于 Linux TCP 套接字，listen() 的 backlog 关注已经建立、等待应用接受的连接；未完成握手的队列是另一种概念。调用 accept() 会移出一条待处理连接，并返回供应用使用的已连接套接字。即使这个套接字之后长时间保持打开或忙碌，它也不再占用监听器的 accept 队列。因此，等待接受与已经接受后的活动状态需要分别计数。

坏掉的样子

如果连接到达速度超过应用接受速度，待处理队列会填满。根据内核行为和设置，新客户端可能遇到重传延迟或超时，而已经接受的请求仍可能正常。进程活着，或者部分请求成功，都不能证明监听器正足够快地接受新连接。问题发生在接受之前时，仅查看业务处理成功率可能看不到完整失败路径。

请求的 backlog 还受到 net.core.somaxconn 限制；只把应用值调得更大，不能超过这个上限。但可观察的精确队列边界与实现有关，因此不能把整数直接当成跨平台承诺，认为必定恰好有那么多同时 connect 成功。应测量实际部署内核，而不是把一个很小的实验结果推广成通用的加一或减一规则。

队列计数也需要上下文。ListenOverflows 和 ListenDrops 是网络命名空间计数，不会自动解释到某个具体服务。其他监听器也能贡献计数，客户端超时也可能来自 accept 队列之外。将生产失败归因于某个 backlog 设置，或者宣称扩大队列能修复问题之前，应结合队列占用、接受进度和计数共同判断。

快速验证

本轮复核没有重跑 Docker 套接字实验，内核参数与溢出结果仍属于此前记录。

把脚本保存为 check-listen-backlog.py，准备宿主 Python、Docker 和固定 Python 镜像后运行。真实套接字操作发生在可丢弃 Linux 容器内，网络只保留回环。记录内核为 6.12.76-linuxkit。脚本读取相关设置但不修改它们，并要求 tcp_abort_on_overflow=0，使本次超时观察对应一个明确、可以检查的前提：

import json,subprocess
image='python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84'
program=r'''
from contextlib import ExitStack
from pathlib import Path
import json,platform,socket
def counters():
 lines=Path('/proc/net/netstat').read_text().splitlines()
 for index,line in enumerate(lines):
 if line.startswith('TcpExt:'):
 return dict(zip(line.split()[1:],map(int,lines[index+1].split()[1:])))
def queued(port):
 for line in Path('/proc/net/tcp').read_text().splitlines()[1:]:
 fields=line.split()
 if fields[3]=='0A' and int(fields[1].split(':')[1],16)==port:
 return int(fields[4].split(':')[1],16)
 raise AssertionError('listener missing')
with ExitStack() as stack:
 def fresh():
 s=stack.enter_context(socket.socket());s.settimeout(.25);return s
 def listener(backlog):
 s=fresh();s.bind(('127.0.0.1',0));s.listen(backlog);return s
 somaxconn=int(Path('/proc/sys/net/core/somaxconn').read_text())
 abort=int(Path('/proc/sys/net/ipv4/tcp_abort_on_overflow').read_text());assert abort==0
 small=listener(1);address=small.getsockname();before=counters();clients=[];timed_out=False
 for _ in range(8):
 client=fresh()
 try:client.connect(address)
 except TimeoutError:timed_out=True;client.close();break
 clients.append(client)
 depth=queued(address[1]);after=counters()
 assert timed_out and depth==len(clients) and 1<=depth<8,(depth,len(clients))
 changes={name:after[name]-before[name] for name in ['ListenOverflows','ListenDrops']}
 assert changes['ListenOverflows']>0 and changes['ListenDrops']>0,changes
 accepted=[]
 for client in clients:
 server,_=small.accept();stack.enter_context(server);accepted.append(server);server.sendall(b'ready')
 reader=stack.enter_context(client.makefile('rb'));assert reader.read(5)==b'ready'
 assert queued(address[1])==0
 for _ in range(4):
 client=fresh();client.connect(address);server,_=small.accept();stack.enter_context(server)
 server.sendall(b'ready');reader=stack.enter_context(client.makefile('rb'));assert reader.read(5)==b'ready'
 accepted.append(server);clients.append(client)
 assert len(accepted)>1 and all(s.fileno()>=0 for s in accepted)
 larger=listener(16)
 for _ in range(6):client=fresh();client.connect(larger.getsockname())
 assert queued(larger.getsockname()[1])==6
 print(json.dumps({'kernel':platform.release(),'somaxconn':somaxconn,'tcp_abort_on_overflow':abort,
 'requested_small_backlog':1,'queued_before_accept':depth,'next_connect_timed_out':timed_out,
 'counter_changes':changes,'accepted_connections_still_open':len(accepted),'larger_backlog_queued':6},sort_keys=True))
'''
result=subprocess.run(['docker','run','--rm','-i','--network','none',image,'python','-'],
 input=program,capture_output=True,text=True,timeout=30)
assert result.returncode==0,result.stderr
record=json.loads(result.stdout);print(json.dumps(record,sort_keys=True))

第一个监听器请求 backlog 为一，并故意不接受连接。在记录环境里，两次客户端 connect 完成，/proc/net/tcp 也报告两条排队连接；下一次 connect 超过客户端设定的二百五十毫秒超时。脚本记录实际深度，而不是断言每个 Linux 版本在这个参数下都必须接受恰好两条。配置参数、实际队列和客户端结果分别被观察。

在这次受控溢出期间，ListenOverflows 和 ListenDrops 各增加一。由于实验有独立网络命名空间，而且只有这些回环监听器，可以把观察与故意暂停接受的监听器关联。示例没有修改全局内核设置，也没有通过改变共享 Docker 虚拟机网络策略来制造失败；归属依据来自隔离范围和明确的连接操作。

随后，应用接受已排队连接，并通过返回的套接字发送短确认。客户端完整读到确认，监听队列下降为零。再建立四条连接并立即接受，同时保持之前接受的套接字打开；最终有六条已接受连接共存，尽管最初请求的 backlog 只有一。这直接区分待接受容量与应用可以同时持有多少条已连接套接字。

第二个监听器请求 backlog 为十六，在任何 accept 发生前，六个客户端完成连接，队列报告六条待处理连接。这说明更大的队列可以吸收本次应用暂停期间的到达突发，却没有证明处理吞吐提高，也没有证明这些客户端已经收到应用响应，更不能据此认为扩大 backlog 就能解决持续过载。

同时调整接受能力与等待容量

记录到的 somaxconn 为 4096，高于两次请求的 backlog。这只是测试环境观察，不是建议复制到另一台主机的调优值。应一起检查应用实际 listen 参数、accept 循环和内核上限。系统上限很高，也不会自动扩大应用明确请求的小 backlog；只改变一侧而不核对另一侧，可能完全没有达到预期容量。

要区分未完成握手与已经建立、等待接受的连接。SYN 队列控制和 SYN-cookie 行为回答的问题，与这里展示的 accept 队列不同。同样，tcp_abort_on_overflow 改变溢出处理方式，开启重置并不增加服务容量。本实验保持它关闭，展示现有策略下客户端看到的超时，而没有把另一种配置行为写成已经实测。

最后，调查接受速度为何落后。事件循环停顿、文件描述符耗尽、分发瓶颈和故意暂停，对 accept 的影响可能不同于已经接受套接字上的慢工作。更大队列只是增加等待空间，需要符合客户端截止时间和内存预算。如果持续到达速度超过服务能接受并处理的速度，增加等待只会推迟容量失败，不会创造持续处理能力。

来源

Linux listen(2)，等待 accept 的已建立连接与 somaxconn 上限，已核验 2026-09-12。
Linux accept(2)，移出待接受连接并返回已连接套接字，已核验 2026-09-12。
Linux IP sysctl documentation，somaxconn、SYN backlog 与 tcp_abort_on_overflow，已核验 2026-09-12。

TCP 保活探测空闲连接

Tue, 05 Oct 2027 00:00:00 +0000

TCP keepalive 询问的是：连接安静了一段时间后，对面的 TCP 端点是否仍然响应。它不询问 HTTP handler 是否正常、数据库查询是否推进、后台工作线程是否卡住。即使应用已经停顿，内核仍然可能确认收到的数据。因此，“传输对端能够回应”和“应用给出了有用结果”必须作为两个不同的观察项。

传输层探针不是应用心跳

保活有助于暴露远端连接状态已经消失，或者网络路径悄悄停止传递报文的情况。实现会在满足空闲条件后发送探针，并按照未响应探针的策略最终报告失败；但单个探针丢失不等于对端死亡，不能把网络中的临时丢包直接解释成确定性故障。

探针在应用字节流以下处理，不会变成 HTTP 请求、数据库查询或 WebSocket 心跳。如果连接终止在代理上，探测对象就是代理自身的 TCP 端点，不是代理后面的源站。某些中间设备的连接跟踪可能受探针影响，但不能由此承诺刷新应用的空闲计时，更不能保证所有 NAT 映射都会一直保留。

已经发出而尚未确认的数据还有自己的重传与失败规则，因此保活参数不是繁忙连接的通用总截止时间。正常 FIN、连接重置、应用读取超时和静默丢包是不同事件，恢复动作也未必相同。知道是哪一层报告了什么错误，比统一把它们写成“连接死了”更有用。

配置真正承载请求的 socket

RFC 1122 对可选保活机制要求默认关闭，并规定默认空闲间隔不得短于两小时且应可配置。但应用和库可以显式启用并选择更短间隔，Go 的拨号器就有自己的设置。因此，查到操作系统默认值，并不能直接推出当前应用实际使用的策略；还需要沿着创建连接的代码检查有效配置。

Linux 的 tcp_keepalive_time、tcp_keepalive_intvl 和 tcp_keepalive_probes 分别表示探测前的空闲秒数、探针间隔和未响应探针数量，文档默认值为 7200、75、9。启用 SO_KEEPALIVE 后，还可以通过 TCP_KEEPIDLE、TCP_KEEPINTVL、TCP_KEEPCNT 为单个 socket 定制策略。这些名称与接口不是 macOS、Windows 通用的系统参数，不能跨平台照搬命令。

应根据期望发现故障的时间、连接规模、短暂丢包容忍度以及中间设备策略选择间隔。把空闲时间加上探针预算，只能得到条件性的估算，不是硬实时承诺。优先限定到目标连接，避免为了一个服务修改影响其他进程的全局默认值；同时检查设置操作是否成功，并确认 socket 上实际启用了保活。

坏掉的样子

只配置 keepalive、没有应用读取期限，请求仍可能长时间等不到业务回复。反过来，应用读取期限已到，也不代表 TCP 连接必然失效，更不能据此证明对端进程死亡。本地超时后贸然重发写操作，可能重复执行对端已经收到的任务。

代理更短的空闲超时仍可能先关闭连接，端点设置了保活也不能替代代理的业务策略。在大量连接上使用过于频繁的探针，还会增加网络流量和耗电。修改参数前，应定位实际终止连接的那一跳，以及触发恢复的具体错误信号，不要同时修改三个计时参数后仅凭“看起来好些了”判断原因。

快速验证

将代码保存为 keepalive_probe.go，在 macOS 或 Linux 上用 Go 1.23 或更新版本执行 go run keepalive_probe.go。读取 SO_KEEPALIVE 的部分使用 Unix socket 接口，因此这份原样代码不是 Windows 操作配方。它只创建回环连接，不修改 sysctl、防火墙或共享服务。

package main

import (
 "errors"
 "fmt"
 "io"
 "net"
 "os"
 "runtime"
 "syscall"
 "time"
)

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func keepalive(connection *net.TCPConn) int {
 raw, err := connection.SyscallConn()
 must(err)
 var value int
 var optionError error
 must(raw.Control(func(fd uintptr) {
 value, optionError = syscall.GetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
 }))
 must(optionError)
 return value
}

func main() {
 listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)})
 must(err)
 defer listener.Close()
 must(listener.SetDeadline(time.Now().Add(2 * time.Second)))
 dialer := net.Dialer{Timeout: 2 * time.Second, KeepAlive: -1}
 connection, err := dialer.Dial("tcp4", listener.Addr().String())
 must(err)
 client := connection.(*net.TCPConn)
 defer client.Close()
 peer, err := listener.AcceptTCP()
 must(err)
 defer peer.Close()

 check(keepalive(client) == 0, "keepalive must start disabled")
 must(client.SetKeepAliveConfig(net.KeepAliveConfig{
 Enable: true, Idle: 30 * time.Second,
 Interval: 10 * time.Second, Count: 3,
 }))
 enabled := keepalive(client)
 check(enabled != 0, "SO_KEEPALIVE must be enabled")
 fmt.Printf("SO_KEEPALIVE: 0 -> %d (enabled); per-socket configuration accepted\n", enabled)

 must(client.SetWriteDeadline(time.Now().Add(2 * time.Second)))
 n, err := client.Write([]byte("ping"))
 must(err)
 check(n == 4, "request must be fully written")
 must(client.SetReadDeadline(time.Now().Add(200 * time.Millisecond)))
 reply := make([]byte, 4)
 n, err = client.Read(reply)
 check(n == 0 && errors.Is(err, os.ErrDeadlineExceeded), "silent application must reach read deadline")
 fmt.Println("read deadline fired while the peer application was silent")

 must(peer.SetDeadline(time.Now().Add(2 * time.Second)))
 request := make([]byte, 4)
 _, err = io.ReadFull(peer, request)
 must(err)
 check(string(request) == "ping", "the original request is still queued")
 n, err = peer.Write([]byte("pong"))
 must(err)
 check(n == 4, "reply must be fully written")
 must(client.SetReadDeadline(time.Now().Add(2 * time.Second)))
 _, err = io.ReadFull(client, reply)
 must(err)
 check(string(reply) == "pong", "same connection must deliver the reply")
 fmt.Println("after resetting the read deadline, the original connection returns pong")
 fmt.Println(runtime.Version(), runtime.GOOS)
}

拨号器先明确禁用保活，再使用单连接配置启用它。getsockopt 返回的启用标志必须是非零，但不保证恰好等于一；已核验的 macOS、Go 1.27.0 环境返回八。对端应用刻意不读取已经发送的四字节请求，客户端在二百毫秒的读取期限到达后得到超时错误，而不是收到业务数据。

之后，对端读取原来排队的 ping，并写回 pong。客户端重新设置读取截止时间，就能在同一条连接上收到回复，期间没有重新建连，也没有重发请求。这个现象说明超时只限制了本地等待，并没有撤回已进入字节流的数据，更没有自动取消远端工作。是否继续使用连接和如何恢复业务，需要由上层协议决定。

全部断言已经通过。这个短实验验证的是 socket 配置与应用读取期限，不是保活探针的真实发送时序：配置的首次探测空闲间隔是三十秒。它没有注入丢包，也没有测量经过 NAT 后的故障发现时间。验证那些能力，需要另行安排受控网络实验，保留报文证据，并检查报告故障之后的资源释放与安全恢复行为。

来源

RFC 1122：互联网主机要求，第 4.2.3.6 节：可选保活、空闲条件与探针丢失，已核验 2026-09-09。
Linux tcp(7)，保活默认值、socket 选项与更短的中间设备超时，已核验 2026-09-09。
Go net，KeepAliveConfig、socket 配置与截止时间语义，已核验 2026-09-09。

SACK 报告缺口之后已收到的范围，帮助定位需要恢复的数据

Sat, 11 Sep 2027 00:00:00 +0000

TCP 累计确认标识按序接收时下一个期待的字节。如果某段缺失、后续字节却已到达，累计确认不能跨过这个空洞。选择确认 SACK 补充报告累计边界之后已经收到的字节范围，帮助发送端区分真正缺失的数据与接收端已经排队的数据。它改善恢复算法获得的信息，而不是替代全部丢包判断、拥塞控制或应用交付语义。

坏掉的样子

没有 SACK，并不意味着累计 ACK 强制发送端重传后面的每一个段。发送端仍可根据重复确认、计时器和恢复算法推断丢失，只是反馈不够明确，尤其在存在多个缺口时。把普通 TCP 描述为必须重发整个后缀，是把信息能力的限制误写成强制恢复策略，会夸大差异，也无法准确解释真实抓包中的局部重传。

SACK 块报告已经收到的范围，不是直接列出缺失范围。每块在序列空间中具有包含的左边界和不包含的右边界。缺口需要结合这些块、累计确认及尚未确认数据推导。SACK 不改变普通 ACK 字段含义，应用仍获得有序字节流，而不是乱序的选择确认块。传输层暂存后续字节，并不等于已经把它们交给应用。

该能力还需要对当前连接取得许可。SYN 中的 SACK-Permitted 表示发送该 SYN 的一端允许对端向自己发送 SACK 选项，不证明一次无丢失传输中实际出现过 SACK 块。反过来，缺少 SACK 也不自动证明防火墙剥离选项。判断原因之前应核对端点设置与真实握手，不能把某种中间设备问题当成唯一解释，忽略连接本身的协商条件。

快速验证

将脚本保存为 check-sack.py，准备 Docker 后运行 python3 check-sack.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套网络命名空间及临时 proc 挂载。实验仅使用新建 veth 和命名空间内部设置，不改变宿主现有流量：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 setting('client','net.ipv4.tcp_sack',1);setting('target','net.ipv4.tcp_sack',1)
 setting('client','net.ipv4.tcp_autocorking',0)
 server_code=r'''
import socket,json,hashlib
listener=socket.socket();listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
with listener.accept()[0] as connection:
 connection.settimeout(6);data=b''
 while len(data)<12*256:
 chunk=connection.recv(4096);assert chunk;data+=chunk
 expected=b''.join(bytes([i])*256 for i in range(12));assert data==expected
 result={'bytes':len(data),'sha256':hashlib.sha256(data).hexdigest()}
 connection.sendall(json.dumps(result).encode()+b'\n');print(json.dumps(result),flush=True)
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='listening'
 nft('target','''table ip one_gap {
 chain input { type filter hook input priority 0; policy accept;
 tcp dport 18080 ip length > 100 numgen inc mod 2147483647 == 1 counter drop comment "second_data_packet"
 }
}
''')
 tap,path=capture(stack,root,'client','c0','tcp port 18080','sack')
 client_code=r'''
import socket,json,time,hashlib
s=socket.socket();s.settimeout(6);s.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1)
s.bind(('192.0.2.1',40500));s.connect(('192.0.2.2',18080))
for i in range(12):s.sendall(bytes([i])*256);time.sleep(.003)
with s.makefile('rb') as stream:result=json.loads(stream.readline())
expected=b''.join(bytes([i])*256 for i in range(12))
assert result=={'bytes':len(expected),'sha256':hashlib.sha256(expected).hexdigest()}
print(json.dumps(result));s.close()
'''
 result=json.loads(ns('client','python3','-c',client_code).stdout);assert json.loads(line(service))==result
 dropped=counters('target');assert dropped['second_data_packet']==1,dropped
 observed=packets(tap,path);syn=next(p for p in observed if p['flags']&0x12==0x02);synack=next(p for p in observed if p['flags']&0x12==0x12)
 assert syn['options'].get('sack_ok') and synack['options'].get('sack_ok')
 reports=[p for p in observed if p['sport']==18080 and p['options'].get('sack')]
 assert reports,observed
 data_start=(syn['seq']+1)%2**32
 def relative(sequence):return (sequence-data_start)%2**32
 hole=(data_start+256)%2**32
 assert any(relative(p['ack'])==256 and any(256<relative(left)<relative(right)<=3072 for left,right in p['options']['sack']) for p in reports),reports
 retransmissions=[p for p in observed if p['sport']==40500 and p['length'] and p['seq']==hole]
 assert len(retransmissions)>=2,retransmissions
 print(json.dumps({'sack_negotiated_both_directions':True,'missing_byte_sequence':hole,'sack_reports':reports,
 'original_and_retransmitted_hole':retransmissions,'drop_counter':dropped,'verified_delivery':result}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

两端启用 SACK。客户端启用 TCP_NODELAY，并关闭自己命名空间的自动 corking，然后间隔短暂时间发送十二块可区分数据，每块256字节。目标输入链使用递增表达式，仅丢弃第二个匹配数据包。很大的取模值使这段短传输只出现一次受控丢弃，计数器必须恰好报告一次，避免把不可控随机丢失冒充固定实验条件。

捕获确认两个 SYN 消息均包含 SACK-Permitted。第一块到达后，第二块缺失形成空洞。接收端累计确认停在缺口的首字节，而 SACK 块描述后来已经接收的范围。脚本使用本次实际初始序列号检查这些关系，不要求每次运行采用同一个序列值。数字大小本身没有固定意义，范围之间的对应关系才是需要验证的协议事实。

缺失范围在捕获中先以原始发送段出现，随后以相同序列号重传，本次长度为256字节。服务器最终按预期顺序收到全部3072字节，并检查内容，再返回 SHA-256 摘要。客户端独立将该摘要与计划发送的载荷比较。因此，结果不只是“连接没报错”，而是同时确认重传后真正交付了完整且正确的数据。

这些观察证明真实缺口、有效确认信息、重传与成功交付，却没有对比关闭 SACK 的性能，也不能建立统一重传次数改善比例。单独这份捕获，同样无法说明 Linux 丢失检测决策的每个细节。协商 SACK 与选择何时重传，是相关但不同的传输实现部分；不能把出现一个选择确认块，直接解释成某个特定恢复算法必定触发。

解释反馈时，不承诺重传判断绝对完美

RFC 2018 将 SACK 定义为建议性信息，接收端之后可能丢弃此前报告的数据。因此，发送端不能把 SACK 当作永久应用收据，也不能仅因某个范围出现在选项里，就放弃全部重传责任。累计确认仍是判断哪些字节已被 TCP 按序接受的核心依据，业务是否处理或持久保存数据，还属于更高一层的确认契约。

乱序也可能产生缺口和选择报告，即使报文没有永久丢失。应关联序列范围、重传时间、累计进展与捕获位置，再判断是否存在网络损坏。本例的明确输入过滤和精确丢弃计数，为刻意丢失提供直接证据；原因不明的生产抓包通常没有这种实验控制，不能照搬故障归因，需要补充对应观察。

事件排查应保留握手选项，以及足以重建相关范围的数据交换，分别比较应用交付和传输恢复。正确重组可能使短暂网络丢失不影响应用内容，却仍影响延迟或吞吐量。性能问题需要代表性负载测量，本例则验证协议信息与最终字节交付。这样既能说明 SACK 的作用，也不会用一个小型成功样本替代完整网络性能结论。

来源

RFC 2018 TCP Selective Acknowledgment，已接收字节范围、许可方向与 SACK 的建议性质，已核验 2026-09-12。
RFC 9293 TCP，累计确认、序列空间与可靠字节交付，已核验 2026-09-12。
Linux tcp(7)，Linux TCP SACK 配置与套接字诊断，已核验 2026-09-12。

TCP 握手建立序列号空间，不是同步两台机器的时钟

Fri, 10 Sep 2027 00:00:00 +0000

TCP 三次握手建立字节流的两个方向。每端提供自己的初始序列号，并确认另一端的序列号。这是两个独立序列空间，不是共享墙上时钟；应用建立连接不需要两台机器时钟同步。之后的序列号用于标识字节，支持连接内部的排序、重复处理、确认和重传。把序列号与时间混为一谈，会误解握手真正建立的协议状态。

坏掉的样子

客户端发送带初始序列号的 SYN，服务器回复 SYN-ACK，给出自己的初始序列号并确认客户端 SYN，客户端再确认服务器响应。即使没有应用数据，SYN 也占用序列空间中的一个位置，所以对应确认号增加一。将这些数值当成时间戳，会错误解释报文，还可能把排障引向无关的时钟同步问题，忽略真正缺失的确认或路由。

两端不会在完全相同的时刻改变状态。客户端收到 SYN-ACK 后，connect 可能成功返回，但最后一个确认在到达服务器前丢失。服务器仍可能停留在 SYN-RECEIVED，Linux 工具显示为 SYN-RECV。后续携带适当确认的数据也能完成交换，因此单独第三个报文缺失，并不必然导致永久失败，不能把抓包中的固定三包模式当成唯一合法过程。

TCP 建立成功也不代表应用健康或对端身份可信。服务可能接受连接却无法生成有效响应，代理可能完成客户端这一侧连接，却无法建立另一个独立上游连接。初始序列号选择有助于区分连接实例、抵御预测攻击，但不是身份认证协议，也不会加密字节流。传输状态、应用结果和安全身份需要各自对应的验证，不能由一项成功代替全部。

快速验证

将脚本保存为 check-tcp-handshake.py，准备 Docker 后运行 python3 check-tcp-handshake.py。一次性容器使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套网络命名空间。客户端和目标由新建 veth 相连，不移动宿主接口或发布端口：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 server_code=r'''
import socketserver
class Handler(socketserver.StreamRequestHandler):
 def handle(self):
 data=self.rfile.readline();self.wfile.write(b'echo:'+data);self.wfile.flush()
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
server=Server(('192.0.2.2',18080),Handler);print('ready',flush=True);server.serve_forever()
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='ready'
 tap,path=capture(stack,root,'client','c0','tcp port 18080','handshake')
 normal=ns('client','python3','-c',
 'import socket; s=socket.socket();s.settimeout(2);s.bind(("192.0.2.1",40100));s.connect(("192.0.2.2",18080));s.sendall(b"normal\\n");print(s.makefile("rb").readline().decode().strip());s.close()')
 assert normal.stdout.strip()=='echo:normal'
 nft('client','''table ip missing_ack {
 chain output { type filter hook output priority 0; policy accept;
 tcp dport 18080 tcp flags & (syn|ack|rst|fin) == ack counter drop comment "missing_final_ack"
 }
}
''')
 client_code=r'''
import json,socket,sys
s=socket.socket();s.settimeout(.25);s.bind(('192.0.2.1',40101));s.connect(('192.0.2.2',18080))
print(json.dumps({'connect_returned':True}),flush=True);s.sendall(b'deferred\n')
try:s.recv(64);raise AssertionError('unexpected application response')
except TimeoutError:print(json.dumps({'application_timeout':True}),flush=True)
assert sys.stdin.readline().strip()=='restore';s.settimeout(5)
received=b''
while not received.endswith(b'\n'):
 chunk=s.recv(64);assert chunk,'premature EOF';received+=chunk
assert received==b'echo:deferred\n',received
print(json.dumps({'recovered':received.decode().strip()}),flush=True);s.close()
'''
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code])
 connected=json.loads(line(client));failure=json.loads(line(client));assert connected['connect_returned'] and failure['application_timeout']
 pending=ns('target','ss','-nHt','state','syn-recv').stdout;assert '192.0.2.1:40101' in pending,pending
 blocked=counters('client');assert blocked['missing_final_ack']>0
 nft('client','delete table ip missing_ack');client.stdin.write('restore\n');client.stdin.flush()
 recovery=json.loads(line(client,6));assert recovery['recovered']=='echo:deferred'
 client.wait(timeout=2);assert client.returncode==0
 observed=packets(tap,path);flow=[p for p in observed if 40100 in (p['sport'],p['dport'])]
 syn=next(p for p in flow if p['flags']&0x12==0x02)
 synack=next(p for p in flow if p['flags']&0x12==0x12)
 third=next(p for p in flow if p['sport']==40100 and p['flags']&0x12==0x10)
 assert synack['ack']==(syn['seq']+1)%2**32
 assert third['seq']==(syn['seq']+1)%2**32 and third['ack']==(synack['seq']+1)%2**32
 print(json.dumps({'three_messages':[syn,synack,third],'normal_reply':normal.stdout.strip(),
 'client_connect_returned':connected['connect_returned'],'application_timeout':failure['application_timeout'],
 'server_still_syn_recv':pending.strip(),'drop_counters':blocked,'after_ack_filter_removed':recovery}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

第一条连接使用客户端端口 40100 和目标端口 18080，发送换行结束的请求，收到预期回显。抓包提供真实 SYN、SYN-ACK 和最终 ACK 数值。断言检查服务器确认号等于客户端序列号加一，第三条消息确认号等于服务器序列号加一，并对三十二位序列空间使用取模运算。这样验证的是协议关系，而不是要求每次随机数相同。

第二条连接使用客户端端口 40101。客户端命名空间输出规则丢弃带 ACK、但不带 SYN、FIN 或 RST 的报文，包含最后确认与后续数据。阻断后续数据很重要，否则新的数据段可能确认 SYN-ACK，修复刻意丢失的第三条消息。实验由此稳定暴露两端不同状态，而不是依赖短暂时序巧合，或错误地假定一个 ACK 丢失后永远无法恢复。

客户端报告 connect 已成功返回，但读取应用响应直到截止时间仍失败。同一观察点，服务器套接字列表显示该客户端四元组处于 SYN-RECV，规则计数器也确认发生丢弃。三个独立观察分别对应客户端本地 API 结果、服务器协议状态和应用交换失败，证明它们不能混成同一项“连接正常”。故障归因需要同时保存这些上下文。

移除规则后，同一连接可以继续完成交换并交付已排队请求。客户端收到 echo:deferred，没有新建替代套接字来掩盖原连接失败。带边界的读取会累积响应，不假定一次 recv 总能返回完整应用消息。测试同时验证临时失败，以及受控原因移除之后的恢复；恢复来自 TCP 后续传输与确认，不是应用重开连接造成的另一个成功样本。

分别诊断建立过程和有效服务

记录四元组、命名空间、捕获位置与两端状态。重置、反复 SYN、反复 SYN-ACK，以及握手完成后的应用超时，会指向不同的下一步检查。条件允许时捕获两个方向：本地看到一个确认离开，不代表远端已经收到。本例通过规则计数和远端状态补足这个缺口，避免只看单侧包迹就宣布服务器一定进入已建立状态。

验证服务时，应在传输连接之后发送有意义的请求并检查响应。验证身份和机密性时，应使用 TCP 上层适当的认证协议。本例覆盖没有 Fast Open 或同时打开的普通连接，不声称每个合法连接都以三个分离可见的报文开始。关键是序列号与状态的关系，而不是简单数包，更不能把握手成功当作业务操作已经完成的证明。

来源

RFC 9293 TCP，序列号、连接状态与三次握手，已核验 2026-09-12。
Linux tcp(7)，TCP 套接字行为与 Linux 控制选项，已核验 2026-09-12。
Linux ss(8)，查看已建立与 SYN-RECV 套接字，已核验 2026-09-12。

HTTP keep-alive：复用同一条连接

Fri, 28 May 2027 00:00:00 +0000

HTTP 持久连接允许多次请求与响应复用同一条连接，减少重复的 TCP 建连；使用 HTTPS 时，也可能省去新的 TLS 协商。收益取决于网络延迟、响应大小、服务端处理时间以及池中是否已经有可用连接。连接复用不会消除业务计算，也没有承诺某个套接字永远保持打开。讨论优化之前，先明确观察的是哪一段连接、哪个协议版本。

完整报文才允许复用

HTTP/1.1 默认允许持久连接，除非某一方发送 Connection: close，或实际关闭传输连接。通常不必额外添加 Connection: keep-alive。客户端连接池可以保留空闲连接，供符合源、代理、证书和池策略的后续请求使用。连续执行两次独立的命令行程序，通常不会共享内存中的连接池，因而不能凭两次响应成功就断言已经复用。

复用的前提是双方都能识别每条消息的结束位置。响应可以通过准确的 Content-Length、分块传输编码，或无正文响应的协议规则界定边界。如果只能依赖关闭连接表示正文结束，这条连接自然无法留给下一次请求。客户端需要读完响应正文；服务器需要读完请求正文，或者关闭连接。残留字节一旦被当成下一条消息解析，问题就从性能退化变成报文错位。

HTTP 持久连接与 TCP keepalive 也是两回事。后者在传输连接空闲足够久后发送探测，帮助识别失联的对端，不负责 HTTP 消息分界，也不能覆盖代理或应用自己的空闲超时。仅仅打开操作系统的探活选项，并不会让一个已经被代理回收的连接重新可用。排查时应分别记录应用层关闭、传输层错误和连接池回收动作。

顺序复用还不同于流水线请求。客户端可以等前一个响应完成后再发送下一条请求，同时一直使用相同连接。HTTP/1.1 流水线允许提前发送请求，但响应仍须按序返回。因此，仅有持久连接并不具备 HTTP/2 多路复用提供的独立响应流，不能把两者的并发收益混为一谈。

每一跳管理自己的超时

空闲超时按照具体实现的规则衡量无活动时间，请求截止时间则限制一次操作能等待多久，两者需要独立配置。反向代理同时拥有客户端连接和上游连接，两侧可能使用不同协议、连接池和超时。因此，浏览器到边缘复用了连接，并不能证明边缘到源站也复用；看到一侧握手减少，也不能直接解释另一侧的延迟变化。

连接池应结合已知的服务端限制提前淘汰空闲连接，但始终可能发生竞态：客户端刚发送下一条请求，服务器恰好开始关闭。监控应同时包含新建连接数、成功复用次数、连接重置、池占用和请求延迟。保留更久可以减少握手，也会占用文件描述符与内存。应依据实际请求间隔和资源预算确定保留策略，不能仅凭“站点很忙”推导一个固定超时。

坏掉的样子

正文长度错误可能让读取方一直等待，或让下一条响应的开头混进上一条正文。遇到请求挂起时先检查消息分界，再考虑调大超时。另一个常见故障是调用方放弃流式响应，却既不读完也不关闭，导致池中的连接长期占用。此时服务器还有处理能力，新的请求却全在客户端等空位，扩大服务端容量无法解决这个问题。

陈旧连接报错不代表服务器没有执行请求。如果支付已经提交而响应在回程丢失，自动重连并原样重发可能重复扣款。是否重试必须依照方法语义和业务幂等契约判断，不能把传输异常当成回滚证明。HTTP/2 虽然可以在连接上复用多个流，却禁止 Connection、Keep-Alive 等 HTTP/1.x 专属字段；把这些头搬进 HTTP/2 配置没有优化意义。

快速验证

下面是可直接运行的 Python 3 实验：服务器绑定系统分配的回环端口，客户端连续请求四次，结束后关闭测试服务器。它不需要外部服务；内置 HTTP 服务器只用于本地验证，不是部署配置。

from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread

class Handler(BaseHTTPRequestHandler):
 protocol_version = "HTTP/1.1"

 def do_GET(self):
 self.server.connections.append(self.connection)
 self.send_response(200)
 self.send_header("Content-Length", "2")
 if self.path == "/close":
 self.send_header("Connection", "close")
 self.end_headers()
 self.wfile.write(b"ok")

 def log_message(self, *args):
 pass

with ThreadingHTTPServer(("127.0.0.1", 0), Handler) as server:
 server.connections = []
 worker = Thread(target=server.serve_forever, daemon=True)
 worker.start()
 client = HTTPConnection(*server.server_address, timeout=3)
 try:
 for path in ("/one", "/two", "/close", "/four"):
 client.request("GET", path)
 response = client.getresponse()
 assert response.status == 200
 assert response.read() == b"ok"
 sockets = server.connections
 print("reused:", sockets[0] is sockets[1] is sockets[2])
 print("new after close:", sockets[2] is not sockets[3])
 finally:
 client.close()
 server.shutdown()
 worker.join()

预期输出是 reused: True 和 new after close: True。前两次完整读取正文后，第三次仍使用同一个套接字；第三次收到显式关闭指示后，第四次重新建连。这里比较的是服务器持有的连接对象，不是容易误读的响应耗时。实验只证明本地 HTTP/1.1 的复用与关闭行为，没有覆盖 TLS、浏览器连接池或生产代理；部署验证仍应逐跳检查连接标识与新建连接计数。

来源

RFC 9112：HTTP/1.1 连接管理，消息分界、持久连接、重试和关闭，已核验 2026-09-06。
MDN：HTTP/1.x 连接管理，持久连接及其资源成本，已核验 2026-09-06。
RFC 9113：HTTP/2 连接专属字段，HTTP/2 消息禁止使用的字段，已核验 2026-09-06。

调整 MSS 可以恢复一条 TCP 路径，却不会修复 MTU 反馈

Sun, 24 Jan 2027 00:00:00 +0000

TCP 最大段大小选项 MSS，按照其定义的开销规则，通告接收端可接受的 TCP 数据大小。两个方向分别通告，数值不必相同。路由器转发 SYN 消息时可以减小这些值，使后续数据段适应受限路径。这改变的是相关连接的 TCP 行为，不会修改底层链路 MTU。把选项调整与网络本身修复区分开，才能准确说明它解决了什么。

坏掉的样子

中间瓶颈可能比两个端点接口都小。如果经典路径 MTU 反馈被过滤，连接可以成功建立，却在较大数据上停滞。降低 MSS 能帮助该 TCP 流量避开超大报文，但缺失的反馈仍然缺失。若把这个变通措施当作完整网络修复，其他协议与流量模式仍可能暴露原有问题，健康检查也可能继续遗漏受影响场景。

MSS 不是完整 IP 包大小。IPv4 路径 MTU 为 1280、普通 IPv4 与 TCP 基础头各占 20 字节时，基本计算得到通告 MSS 1240。形成真实数据段时，还要为实际 IP 或 TCP 选项另外留空间。把通告值直接等同于最终线路报文长度，可能使看似保守的设置仍然超限。应明确每个数字包含哪些头部，而不是只套一个固定减法。

方向和时机也很重要。只修改一个 SYN 方向，另一端通告仍保持原样；更新规则，也不会改写已有连接早先交换过的选项。真正的限制应降低过大通告，而不是抬高对端原本更小的上限。策略应针对真实瓶颈和相关流量，不能把一个硬编码值视为所有网络都合适，也不能假定旧连接会自动采用新配置。

快速验证

将脚本保存为 check-mss-clamp.py，准备 Docker 后运行 python3 check-mss-clamp.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持四个嵌套命名空间。端点链路 MTU 为 1500，两台路由器之间的链路为 1280：

from pathlib import Path
from tempfile import TemporaryDirectory
import subprocess,json,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time
def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,process.stderr.read();return value
@contextmanager
def lab():
 with TemporaryDirectory(prefix='mtu-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc));stack.callback(run,'umount',str(proc))
 for name in ['client','r1','r2','target']:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False);ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in ['client','r1','r2','target']
 path=proc/'sys'/key.replace('.','/')
 ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r});p.write_text({str(value)!r});assert p.read_text().strip()=={str(value)!r}')
 yield root,stack,setting
def topology(setting,ipv6=False):
 links=[('client','c0','r1','a0',1,2,1,1500),('r1','a1','r2','b0',2,1,2,1280),('r2','b1','target','t0',3,1,2,1500)]
 for left,left_if,right,right_if,network,left_host,right_host,mtu in links:
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,host in [(left,left_if,left_host),(right,right_if,right_host)]:
 run('ip','link','set',interface,'netns',name);ip(name,'link','set',interface,'mtu',str(mtu))
 address=f'2001:db8:{network}::{host}/64' if ipv6 else f'10.210.{network}.{host}/30'
 ip(name,'addr','add',address,'dev',interface,*(['nodad'] if ipv6 else []));ip(name,'link','set',interface,'up')
 family='-6' if ipv6 else '-4'
 for name in ['r1','r2']:setting(name,'net.ipv6.conf.all.forwarding' if ipv6 else 'net.ipv4.ip_forward',1)
 routes=[('client','default','2001:db8:1::1' if ipv6 else '10.210.1.1'),('target','default','2001:db8:3::1' if ipv6 else '10.210.3.1'),
 ('r1','2001:db8:3::/64' if ipv6 else '10.210.3.0/30','2001:db8:2::2' if ipv6 else '10.210.2.2'),
 ('r2','2001:db8:1::/64' if ipv6 else '10.210.1.0/30','2001:db8:2::1' if ipv6 else '10.210.2.1')]
 for name,destination,gateway in routes:ip(name,family,'route','add',destination,'via',gateway)
 if ipv6:
 deadline=time.monotonic()+4
 while any('tentative' in ip(name,'-6','address','show').stdout for name in ['client','r1','r2','target']):
 assert time.monotonic()<deadline,'IPv6 link-local DAD did not finish';time.sleep(.02)
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 result={}
 for item in json.loads(ns(name,'nft','-j','list','ruleset').stdout)['nftables']:
 rule=item.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:result[rule['comment']]=expression['counter']['packets']
 return result
def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'capture exited'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('capture did not become ready')
def captured(process,path):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3);assert process.returncode==0,diagnostic
 return run('tcpdump','-nn','-vv','-r',str(path)).stdout


def server(stack):
 code=r'''
import socketserver,hashlib
class Handler(socketserver.StreamRequestHandler):
 def handle(self):
 self.request.settimeout(3)
 header=self.rfile.readline()
 if not header:return
 length=int(header);data=self.rfile.read(length)
 if len(data)!=length:return
 self.wfile.write(hashlib.sha256(data).hexdigest().encode()+b'\n');self.wfile.flush()
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
service=Server(('10.210.3.2',18080),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec','target','python3','-u','-c',code]);assert line(process).strip()=='ready'
def transfer(size):
 code=r'''
import socket,json,hashlib,sys,struct
size=int(sys.argv[1]);stream=socket.socket();stream.settimeout(1.5);connected=False
try:
 stream.connect(('10.210.3.2',18080));connected=True
 stream.sendall(str(size).encode()+b'\n'+b'x'*size)
 with stream.makefile('rb') as incoming:reply=incoming.readline().decode().strip()
 assert reply==hashlib.sha256(b'x'*size).hexdigest()
 print(json.dumps({'ok':True,'connected':True,'bytes':size,'sha256':reply,'snd_mss':stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_MAXSEG)}))
except OSError as error:
 stream.setsockopt(socket.SOL_SOCKET,socket.SO_LINGER,struct.pack('ii',1,0))
 print(json.dumps({'ok':False,'connected':connected,'type':type(error).__name__,'errno':error.errno}))
finally:stream.close()
'''
 return json.loads(ns('client','python3','-c',code,str(size)).stdout)
def hide_fragmentation_feedback():
 nft('r1','''table ip hidden_mtu {
 chain output { type filter hook output priority 0; policy accept;
 icmp type destination-unreachable icmp code frag-needed counter drop comment "fragmentation_feedback_dropped"
 }
}
''')
with lab() as (root,stack,setting):
 topology(setting);setting('client','net.ipv4.tcp_mtu_probing',0);server(stack);hide_fragmentation_feedback()
 failed=transfer(65536);assert failed['connected'] and not failed['ok'] and failed['type']=='TimeoutError'
 initial_counter=counters('r1')['fragmentation_feedback_dropped'];assert initial_counter>0
 nft('r1','''table ip clamp {
 chain forward { type filter hook forward priority 0; policy accept;
 tcp flags & syn == syn tcp option maxseg size > 1240 tcp option maxseg size set 1240 counter comment "mss_rewritten"
 }
}
''')
 tap,path=capture(stack,root,'client','c0','tcp port 18080','mss')
 recovered=transfer(65536);assert recovered['ok'] and recovered['snd_mss']<=1240,recovered
 trace=captured(tap,path);assert 'mss 1240' in trace,trace
 after_transfer=counters('r1');assert after_transfer['mss_rewritten']>=2 and after_transfer['fragmentation_feedback_dropped']==initial_counter,after_transfer
 large_ping=ns('client','ping','-n','-M','do','-s','1400','-c','1','-W','1','10.210.3.2',check=False)
 assert large_ping.returncode!=0 and counters('r1')['fragmentation_feedback_dropped']>initial_counter
 print(json.dumps({'before_clamp':failed,'after_clamp':recovered,'counters_after_tcp':after_transfer,
 'icmp_echo_still_fails':{'returncode':large_ping.returncode,'stdout':large_ping.stdout,'stderr':large_ping.stderr},'capture':trace}))
"""
name='xbcatm-mtupath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN','--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

第一台路由器抑制向外发送的 ICMP 需要分片消息，客户端关闭独立 TCP MTU 探测，从而构成受控的经典发现失败。65536 字节传输完成 TCP 建立后达到应用截止时间，路由器计数确认反馈被抑制。失败套接字随后中止，防止其残留重传被误认成后面比较中的报文。这里首先建立明确失败基线，而不是只展示添加规则后的成功。

脚本添加转发规则，匹配带 SYN 且通告 MSS 大于 1240 的 TCP 报文，将该选项设为 1240 并计数。SYN-ACK 同样带有 SYN，所以相应返回通告也被覆盖。比较使用全新连接，因为已建立字节流仍保留自身握手期间收到的选项。条件限制保证不会主动抬高原本较小的值，但不能因此省略生产环境的方向与范围审阅。

新的 65536 字节传输成功，并验证返回的 SHA-256 摘要。捕获显示 MSS 已减小，规则计数记录两个握手方向的变化。本次实际发送 MSS 为 1228，因为生效的 TCP 选项还占用额外空间。成功传输期间，需要分片反馈的丢弃计数没有增长，说明完成它不再依赖此前受损的反馈路径，而不是反馈过滤已经被悄悄移除。

之后，载荷 1400 字节并设置禁止分片的 IPv4 echo 探测仍然失败，被抑制反馈的计数再次增加。这个较大的 ICMP 包不属于 TCP MSS 机制：修改 TCP 握手选项，既没有把它缩小，也没有修复路由器反馈策略。两种流量的不同结果，通过实际通信明确了变通措施范围，不能把 TCP 成功推广成所有协议都已恢复。

让变通措施对应实际包大小约束

本地捕获包含可能大于最终 TCP 分段的卸载表示，也可能显示看似不完整的校验和。不能仅凭这些记录，就断言 MSS 被忽略，或巨大报文已经穿过 1280 字节链路。选项、套接字诊断、计数器和经过验证的应用响应，分别提供不同处理阶段的证据。保持观察点一致，才能避免把内核表示与最终线路帧混淆。

合适上限应依据真实封装和 IP 版本推导。IPv6 外层头或额外隧道开销会改变包预算，路径变化也可能使曾经足够的固定值失效。本隔离拓扑使用已知瓶颈，规则不是自动发现算法，不能保证学习之后的每次路由变化。部署到其他网络前，应重新核对相应路径，而不是因为示例数值通过就直接复用。

生产策略生效后，应测试新连接和相关非 TCP 流量，保留对端本来更小的通告，并在上传、下载行为不同时检查两个方向。条件允许时，优先修复必要反馈与路径配置。MSS 调整的价值来自职责明确、范围匹配，并且目标 TCP 交互经过真实验证。只看到规则存在或握手完成，仍不足以宣布大传输问题已经解决。

来源

RFC 6691 TCP Options and MSS，MSS 通告与实际头部选项开销计算，已核验 2026-09-12。
nftables packet-header mangling，在 SYN/SYN-ACK 修改 MSS 与双向独立通告，已核验 2026-09-12。
RFC 1191 Path MTU Discovery，MSS 调整本身无法修复的 IPv4 路径发现问题，已核验 2026-09-12。
Linux segmentation offloads，本地卸载表示与最终 TCP 分段，已核验 2026-09-12。

路径 MTU 发现失效时，握手和小请求仍可能成功

Sat, 14 Nov 2026 00:00:00 +0000

路径 MTU 是某条具体路由上各链路 MTU 的最小值。发送端不能只根据自身接口确定它，因为中间链路可能只能承载更小的数据包。经典 IPv4 路径 MTU 发现设置禁止分片标志，通过 ICMP“需要分片”反馈降低估计包大小。路由能够到达目的地，与发送大小适合整条路径，是两项不同条件，前者成立不能自动证明后者。

坏掉的样子

隧道或其他受限中间链路，可能使大传输失败，而 TCP 握手与小请求仍然成功。小报文能够通过瓶颈，因此这些成功没有验证完整大小的数据。反复只测短 ping 或微小健康响应，就可能漏掉影响上传、大响应或持续传输的路径 MTU 问题。应让检查包含真实负载中会触发限制的大小，避免健康探针与实际业务长期脱节。

过滤必要 ICMP 反馈，会让过大报文进入黑洞。发送端观察到没有进展，却缺少指出更小 MTU 的经典信号。其他探测机制可能提供帮助，取决于传输协议和配置，因此不能断言所有 TCP 实现遇到这种过滤都会永久卡住。作出结论前，应查明实际启用了哪一种发现或黑洞恢复机制，不能把某个实验控制条件省略后推广到所有环境。

路径信息还可能被缓存。成功发现之后进行的测试，即使防火墙改变，也可能与全新客户端表现不同。复用已有状态会隐藏反馈路径损坏。路由变化和非对称返回路径进一步增加复杂性，所以需要记录方向、来源、目的地，以及估计是在什么条件下学到的。配置变化前后的结果，只有在这些前提清楚时才适合直接比较。

快速验证

以下命名空间、抓包与套接字集成原样保留，本轮未重跑；观察属于历史记录，离线检查不能复现网络结果。

将脚本保存为 check-path-mtu.py，准备 Docker 后运行 python3 check-path-mtu.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持四个嵌套命名空间，两台路由器通过新建 veth 连接端点，不修改宿主路由或接口：

from pathlib import Path
from tempfile import TemporaryDirectory
import subprocess,json,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time
def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,process.stderr.read();return value
@contextmanager
def lab():
 with TemporaryDirectory(prefix='mtu-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc));stack.callback(run,'umount',str(proc))
 for name in ['client','r1','r2','target']:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False);ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in ['client','r1','r2','target']
 path=proc/'sys'/key.replace('.','/')
 ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r});p.write_text({str(value)!r});assert p.read_text().strip()=={str(value)!r}')
 yield root,stack,setting
def topology(setting,ipv6=False):
 links=[('client','c0','r1','a0',1,2,1,1500),('r1','a1','r2','b0',2,1,2,1280),('r2','b1','target','t0',3,1,2,1500)]
 for left,left_if,right,right_if,network,left_host,right_host,mtu in links:
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,host in [(left,left_if,left_host),(right,right_if,right_host)]:
 run('ip','link','set',interface,'netns',name);ip(name,'link','set',interface,'mtu',str(mtu))
 address=f'2001:db8:{network}::{host}/64' if ipv6 else f'10.210.{network}.{host}/30'
 ip(name,'addr','add',address,'dev',interface,*(['nodad'] if ipv6 else []));ip(name,'link','set',interface,'up')
 family='-6' if ipv6 else '-4'
 for name in ['r1','r2']:setting(name,'net.ipv6.conf.all.forwarding' if ipv6 else 'net.ipv4.ip_forward',1)
 routes=[('client','default','2001:db8:1::1' if ipv6 else '10.210.1.1'),('target','default','2001:db8:3::1' if ipv6 else '10.210.3.1'),
 ('r1','2001:db8:3::/64' if ipv6 else '10.210.3.0/30','2001:db8:2::2' if ipv6 else '10.210.2.2'),
 ('r2','2001:db8:1::/64' if ipv6 else '10.210.1.0/30','2001:db8:2::1' if ipv6 else '10.210.2.1')]
 for name,destination,gateway in routes:ip(name,family,'route','add',destination,'via',gateway)
 if ipv6:
 deadline=time.monotonic()+4
 while any('tentative' in ip(name,'-6','address','show').stdout for name in ['client','r1','r2','target']):
 assert time.monotonic()<deadline,'IPv6 link-local DAD did not finish';time.sleep(.02)
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 result={}
 for item in json.loads(ns(name,'nft','-j','list','ruleset').stdout)['nftables']:
 rule=item.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:result[rule['comment']]=expression['counter']['packets']
 return result
def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'capture exited'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('capture did not become ready')
def captured(process,path):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3);assert process.returncode==0,diagnostic
 return run('tcpdump','-nn','-vv','-r',str(path)).stdout


def server(stack):
 code=r'''
import socketserver,hashlib
class Handler(socketserver.StreamRequestHandler):
 def handle(self):
 self.request.settimeout(3)
 header=self.rfile.readline()
 if not header:return
 length=int(header);data=self.rfile.read(length)
 if len(data)!=length:return
 self.wfile.write(hashlib.sha256(data).hexdigest().encode()+b'\n');self.wfile.flush()
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
service=Server(('10.210.3.2',18080),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec','target','python3','-u','-c',code]);assert line(process).strip()=='ready'
def transfer(size):
 code=r'''
import socket,json,hashlib,sys,struct
size=int(sys.argv[1]);stream=socket.socket();stream.settimeout(1.5);connected=False
try:
 stream.connect(('10.210.3.2',18080));connected=True
 stream.sendall(str(size).encode()+b'\n'+b'x'*size)
 with stream.makefile('rb') as incoming:reply=incoming.readline().decode().strip()
 assert reply==hashlib.sha256(b'x'*size).hexdigest()
 print(json.dumps({'ok':True,'connected':True,'bytes':size,'sha256':reply,'snd_mss':stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_MAXSEG)}))
except OSError as error:
 stream.setsockopt(socket.SOL_SOCKET,socket.SO_LINGER,struct.pack('ii',1,0))
 print(json.dumps({'ok':False,'connected':connected,'type':type(error).__name__,'errno':error.errno}))
finally:stream.close()
'''
 return json.loads(ns('client','python3','-c',code,str(size)).stdout)
def hide_fragmentation_feedback():
 nft('r1','''table ip hidden_mtu {
 chain output { type filter hook output priority 0; policy accept;
 icmp type destination-unreachable icmp code frag-needed counter drop comment "fragmentation_feedback_dropped"
 }
}
''')
results={}
for hidden in [False,True]:
 with lab() as (root,stack,setting):
 topology(setting);setting('client','net.ipv4.tcp_mtu_probing',0);server(stack)
 if hidden:hide_fragmentation_feedback()
 small=transfer(128);assert small['ok']
 before=ip('client','route','get','10.210.3.2').stdout
 tap,path=capture(stack,root,'client','c0','icmp or tcp port 18080','pmtu')
 large=transfer(65536);trace=captured(tap,path);after=ip('client','route','get','10.210.3.2').stdout
 if hidden:
 assert not large['ok'] and large['connected'] and large['type']=='TimeoutError',large
 count=counters('r1');assert count['fragmentation_feedback_dropped']>0
 else:
 assert large['ok'] and 'mtu 1280' in after,(large,after)
 assert 'unreachable - need to frag (mtu 1280)' in trace,trace;count={}
 results[str(hidden)]={'small_transfer':small,'large_transfer':large,'route_before':before,'route_after':after,
 'icmp_feedback_filtered':hidden,'counter':count,'capture':trace}
print(json.dumps(results))
"""
name='xbcatm-mtupath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN','--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

两个端点链路 MTU 都是 1500，路由器之间的链路则为 1280。这样放置瓶颈很重要：端点不会仅因自身接口较小，就在握手时直接通告较小 MSS。客户端明确关闭 TCP 的独立 MTU 探测功能，使比较聚焦经典 ICMP 发现。每次试验新建命名空间，防止正常场景学到的目的地估计泄漏到过滤场景，从而掩盖反馈缺失。

允许反馈时，128 字节传输先成功；随后新连接发送 65536 字节，并校验服务器 SHA-256 响应。捕获中出现需要分片、MTU 为 1280 的 ICMP 消息。客户端之后的路由查询显示缓存 MTU 1280，本次启用时间戳的交互中，套接字报告有效发送 MSS 1228。这把控制报文、目的地状态和应用交付连接起来，而不是仅展示配置命令。

第二个拓扑只抑制第一台路由器向外发送的需要分片消息。小传输仍成功，大传输完成 TCP 建立后超时。规则计数器记录实际被抑制的反馈，客户端路由查询则没有学到较小 MTU。这些观察把大小相关故障与刻意缺失的发现信号联系起来，避免错误归因于监听停止，也说明 connect 成功之后仍需要检查真实数据交换。

失败测试套接字会被明确中止，防止排队重传污染后续观察。应用截止时间 1.5 秒只是限制实验长度，不是操作系统完整重试生命周期。成功场景验证准确载荷，失败场景同时保留本地建立结果与超时类型。这样既能说明哪里已经成功，也不会把传输连接建立误报成应用数据已经交付，或把实验截止时间当作协议统一常数。

按正确处理位置解释抓包

本地捕获可能出现很大的卸载表示或看似不完整的校验和。这类记录不一定是最终放上物理链路的分段，因此一个很大的捕获长度，不能证明超大线路报文已经穿过瓶颈。应关联路由状态、ICMP 反馈、有效 MSS 和应用结果，而不是脱离处理上下文解读单个字段。本例确实包含这些容易误读的本地捕获表现，需要保留观察点说明。

诊断路径时使用多个有意义的载荷大小，并计算 IP、传输、选项和隧道开销。ping 载荷不等于完整 IP 包大小，应用一次写入也不等于一个 TCP 段。保留原始失败方向，因为反方向的小响应成功，可能没有触发相同限制。两个方向都可达，不代表它们的包大小条件和缓存状态必然完全一致。

恢复必要反馈或修正实际路径配置后，应从新状态重复代表性传输。针对单一传输协议的变通措施，可能缓解某个应用，却未修复其他协议的发现过程。本实验验证经典 IPv4 发现及其刻意失败，没有认证所有替代探测算法，也没有给任意互联网路径规定统一超时。修复结论应与实际测试协议、方向和负载大小保持一致。

来源

RFC 1191 Path MTU Discovery，IPv4 DF、需要分片反馈与路径估计，已核验 2026-10-15。
Linux ip(7)，路径 MTU 发现与目的地缓存信息，已核验 2026-10-15。
Linux IP sysctl documentation，作为独立可配置机制的 TCP MTU 探测，已核验 2026-10-15。
Linux segmentation offloads，本地报文表示与实际发送分段之间的区别，已核验 2026-10-15。
Linux checksum offloads，本地捕获中的部分校验和解释，已核验 2026-10-15。

TIME-WAIT 保护连接实例，不是独占一个端口号

Fri, 13 Nov 2026 00:00:00 +0000

TIME-WAIT 是 TCP 在某些有序关闭之后继续保留的协议状态。它为必要时重发最后确认、完成关闭交换留出时间，也帮助避免早先连接实例的延迟报文被误认成新连接数据。相关身份包含两端地址和端口，不能把一个 TIME-WAIT 条目简单理解成对某个本地端口号的全局锁。连接四元组和单独端口，是不同范围的概念。

坏掉的样子

普通关闭中，首先发起关闭的一端通常在确认对端 FIN 后进入 TIME-WAIT。这一端可能是客户端，也可能是服务器；同时关闭还可能涉及双方。假定 TIME-WAIT 永远属于服务器，会掩盖真正制造连接周转的工作负载。应查看状态及两端四元组，不能从应用角色推断谁先关闭，也不能把客户端保留该状态直接视为异常。

高频连接周转可能限制到某个目的地的新连接，但 TIME-WAIT 数量很大，本身不证明资源耗尽或应用文件描述符泄漏。应用关闭套接字之后，操作系统仍可保留协议状态。源地址、可用端口、目的地多样性、显式绑定、复用选项与内核行为，都会影响实际限制。诊断资源耗尽之前，应同时测量连接失败与状态分布，而不是只盯一个总数。

混淆 TIME-WAIT 和 FIN-WAIT-2 会导致无效调参。Linux 的 tcp_fin_timeout 控制另一种孤立套接字情形，不是通用的 TIME-WAIT 时长开关。关于 tcp_tw_recycle 的旧建议，也不适用于当前 Linux。复用受到协议安全条件约束，其中包含时间戳相关检查；如果不了解真实套接字路径，仅修改一个参数，就可能产生错误的行为预期。

快速验证

将脚本保存为 check-time-wait.py，准备 Docker 后运行 python3 check-time-wait.py。一次性环境使用 Python 3.11.16 和 iproute2 6.1.0，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间及临时 proc 挂载。客户端与目标通过新建 veth 相连，参数变更只作用于这些范围，不影响宿主服务或接口：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 setting('client','net.ipv4.tcp_tw_reuse',0)
 setting('client','net.ipv4.tcp_timestamps',0);setting('target','net.ipv4.tcp_timestamps',0)
 server_code=r'''
import socketserver,threading
class Handler(socketserver.BaseRequestHandler):
 def handle(self):
 while self.request.recv(4096):pass
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
servers=[Server(('192.0.2.2',port),Handler) for port in [18080,18081]]
for server in servers:threading.Thread(target=server.serve_forever,daemon=True).start()
print('ready',flush=True);threading.Event().wait()
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='ready'
 client_code=r'''
import json,socket
def exchange(destination):
 with socket.socket() as s:
 s.settimeout(2);s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1);s.bind(('192.0.2.1',40200))
 s.connect(('192.0.2.2',destination));s.sendall(b'closed cleanly');s.shutdown(socket.SHUT_WR)
 assert s.recv(4096)==b''
exchange(18080)
try:exchange(18080);same={'ok':True}
except OSError as error:same={'ok':False,'errno':error.errno,'type':type(error).__name__}
assert not same['ok'] and same['errno']==99,same
exchange(18081)
print(json.dumps({'same_tuple':same,'same_source_port_new_destination_port':True}))
'''
 result=json.loads(ns('client','python3','-c',client_code).stdout)
 rows=ns('client','ss','-nHto','state','time-wait').stdout
 assert '192.0.2.1:40200' in rows and '192.0.2.2:18080' in rows and '192.0.2.2:18081' in rows,rows
 target=ns('target','ss','-nHto','state','time-wait').stdout;assert ':40200' not in target,target
 print(json.dumps({'client_active_close':result,'client_time_wait':rows.strip(),'target_time_wait':target.strip(),
 'timestamps_disabled_in_both_namespaces':True,'client_tcp_tw_reuse':ns('client','sysctl','-n','net.ipv4.tcp_tw_reuse').stdout.strip()}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

为稳定复现立即重用同一四元组被拒绝，实验在两端关闭时间戳，并把客户端 tcp_tw_reuse 设为零。这些是明确的实验控制条件，不是建议用于生产的调参组合。启用时间戳的套接字可能走不同安全复用路径，同版本内核源码中也有相关检查。因此，脚本没有声称一个复用参数就决定所有可能结果，读者重现时应保留这些条件。

目标监听端口 18080 和 18081。客户端在绑定源端口 40200 前设置 SO_REUSEADDR，连接第一个目的端口，发送数据，并首先关闭写方向。目标读取完字节流后关闭，客户端读到 EOF，再关闭自己的描述符。这里通过真实协议流量确立客户端为主动关闭端，不是仅凭变量名称把它标成某种连接角色。

紧接着，客户端从相同源地址和端口连接相同目标地址与端口，在上述控制条件下得到 Linux EADDRNOTAVAIL，错误号九十九。只把目的端口改成 18081，仍保留源端口 40200，连接便成功。两次套接字都使用 SO_REUSEADDR，所以比较的是连接四元组差异，没有在尝试之间偷偷改变绑定选项来制造另一个结果。

随后客户端套接字列表显示两个 TIME-WAIT 条目，共用本地端口 40200，分别对应两个目标端口。本次目标端没有相应 TIME-WAIT 条目。观察时客户端两个计时器都接近六十秒。脚本记录这些计时器，没有等待它们到期，也没有把当前 Linux 实测时长称为所有 TCP 实现通用的常数。计时器可见与完整到期行为已经执行，需要明确区分。

先减少无谓周转，再判断是否需要修改复用策略

应用协议允许时，复用连接可以减少反复建立与拆除。连接池仍需要容量边界、失效连接处理和适当截止时间；保留死连接并不能解决周转问题。检查是否每个小操作都主动关闭，或者代理超时、服务器策略迫使客户端不断重连。修复应针对真实生命周期原因，而不是只让状态数量在监控图上变得更小。

调查上限时，记录失败系统调用与错误、两端四元组、活跃连接数和 TIME-WAIT 分布。绑定失败、连接失败与应用等待超时是不同观察。本例有意绑定源端口，让内核自动选择临时端口的应用会走不同分配路径，需要自己的代表性测试。不能把这个受控源端口实验直接换算成所有客户端的并发连接容量。

诊断应保留协议对延迟报文和关闭交换的保护。实际目标是让所需负载下的新连接可靠工作，而不是消灭 TCP 有意保留的状态。任何拟议变更，都要针对部署内核、套接字选项和流量模式验证，并同时检查应用交互与连接状态计数。这样才能确认性能改善没有以丢失正确性边界为代价，也不会把正常协议行为误当泄漏。

来源

RFC 9293 TCP，连接终止、TIME-WAIT 与延迟到达报文，已核验 2026-09-12。
Linux tcp(7)，套接字复用控制与独立的 FIN-WAIT-2 超时，已核验 2026-09-12。
Linux 6.12.76 TCP IPv4 implementation，复用 TIME-WAIT 连接时与时间戳相关的检查，已核验 2026-09-12。

TCP 拥塞控制由每个发送端决定，两端可以使用不同算法

Thu, 12 Nov 2026 00:00:00 +0000

TCP 拥塞控制限制发送端向容量有限、可能被共享的网络注入数据。拥塞窗口约束未确认数据量，采用 pacing 时还会控制发送在时间上的分布。接收端通告窗口施加的是另一类流量控制限制。这些机制相互作用，却描述不同约束，不能笼统合并成一个“发送速度设置”，否则很难判断真正限制当前连接的是哪一部分。

坏掉的样子

两端不需要选择完全相同的拥塞控制算法。每端负责控制自己发送的流量，因此 Reno 客户端能够与 CUBIC 服务器通信。TCP 建立过程协商传输选项，没有要求双方发送算法名称一致。把不同控制器名称诊断成协议不匹配，会分散注意力，掩盖真正的路由、缓冲或应用故障。算法选择需要按方向和具体套接字理解。

算法是否可用，也是需要核对的运行时事实。配置字符串写了某个控制器，不证明内核支持它或允许调用进程选择它。Linux 的 TCP_CONGESTION 按套接字设置，受可用和允许算法约束。应检查调用结果，并回读实际名称，不能默认请求标签已生效。选择失败与选择成功后性能不合适，属于不同问题，需要不同处理。

丢失恢复不存在适用于所有情况的统一曲线。重传超时、快速恢复、显式拥塞通知和基于模型的估计，会因控制器不同而产生不同响应。丢失可能来自拥塞，也可能来自其他原因，发送端仍须按算法规则作出反应。增加缓冲并不能自动修复持续丢包或等待确认的连接，也不能替代对具体恢复状态和触发信号的检查。

快速验证

将脚本保存为 check-congestion-control.py，准备 Docker 后运行 python3 check-congestion-control.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0 和 nftables 1.0.6，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间。新建 veth 两个方向出口各增加十毫秒延迟，不修改宿主接口或生产流量：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


info_code=r'''
import struct
def tcp_info(stream):
 raw=stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_INFO,104);assert len(raw)==104
 offsets={'snd_mss':16,'unacked':24,'rtt_us':68,'snd_ssthresh':76,'snd_cwnd':80,'total_retrans':100}
 return {'ca_state':raw[1],**{key:struct.unpack_from('=I',raw,offset)[0] for key,offset in offsets.items()}}
'''
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 available=ns('client','sysctl','-n','net.ipv4.tcp_available_congestion_control').stdout.split();assert {'reno','cubic'}<=set(available),available
 for name,interface in [('client','c0'),('target','t0')]:
 ns(name,'tc','qdisc','add','dev',interface,'root','netem','delay','10ms','limit','10000')
 server_code=r'''
import socket,json,hashlib
listener=socket.socket();listener.setsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,b'cubic')
listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
with listener.accept()[0] as connection:
 connection.settimeout(8)
 print(json.dumps({'algorithm':connection.getsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,16).split(b'\0')[0].decode()}),flush=True)
 for size in [65536,16384]:
 data=b''
 while len(data)<size:
 chunk=connection.recv(size-len(data));assert chunk;data+=chunk
 assert data==b'x'*size
 connection.sendall((hashlib.sha256(data).hexdigest()+'\n').encode())
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='listening'
 client_code=info_code+r'''
import socket,json,sys,time,hashlib
with socket.socket() as unsupported:
 try:unsupported.setsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,b'xbcatm_absent');raise AssertionError('unexpected available algorithm')
 except OSError as error:selection_failure={'errno':error.errno,'type':type(error).__name__}
assert selection_failure['errno']==2,selection_failure
stream=socket.socket();stream.settimeout(8);stream.setsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,b'reno')
stream.bind(('192.0.2.1',40600));stream.connect(('192.0.2.2',18080))
with stream.makefile('rb') as incoming:
 stream.sendall(b'x'*65536);assert incoming.readline().decode().strip()==hashlib.sha256(b'x'*65536).hexdigest()
 baseline=tcp_info(stream);assert baseline['snd_cwnd']>1
 algorithm=stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,16).split(b'\0')[0].decode()
 print(json.dumps({'baseline':baseline,'algorithm':algorithm,'unavailable_algorithm':selection_failure}),flush=True)
 assert sys.stdin.readline().strip()=='drop';stream.sendall(b'x'*16384)
 deadline=time.monotonic()+4;samples=[]
 while time.monotonic()<deadline:
 state=tcp_info(stream);samples.append(state)
 if state['total_retrans']>baseline['total_retrans'] and state['snd_cwnd']==1 and state['ca_state']==4:break
 time.sleep(.01)
 else:raise AssertionError(('no timeout recovery observed',samples))
 print(json.dumps({'during_blackout':state}),flush=True)
 assert sys.stdin.readline().strip()=='restore'
 assert incoming.readline().decode().strip()==hashlib.sha256(b'x'*16384).hexdigest()
 print(json.dumps({'after_restore':tcp_info(stream),'verified_bytes':65536+16384}),flush=True)
stream.close()
'''
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code])
 baseline=json.loads(line(client));server_result=json.loads(line(service));assert baseline['algorithm']=='reno' and server_result['algorithm']=='cubic'
 nft('target','''table ip blackout {
 chain input { type filter hook input priority 0; policy accept;
 tcp sport 40600 tcp dport 18080 ip length > 60 counter drop comment "data_dropped"
 }
}
''')
 client.stdin.write('drop\n');client.stdin.flush();loss=json.loads(line(client,5))
 count=counters('target');assert count['data_dropped']>0
 nft('target','delete table ip blackout');client.stdin.write('restore\n');client.stdin.flush()
 recovery=json.loads(line(client,8));client.wait(timeout=2);service.wait(timeout=2);assert client.returncode==service.returncode==0
 print(json.dumps({'available':available,'client':baseline,'server':server_result,'loss':loss,'drop_counter':count,'recovery':recovery}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

脚本首先验证 Reno 与 CUBIC 可用。刻意选择一个不存在的控制器会失败，返回 ENOENT，错误号二，Python 表现为 FileNotFoundError。这个异常指控制器选择不可用，不是应用数据文件丢失。真实客户端明确选择 Reno，服务器监听套接字选择 CUBIC，接受后的套接字报告继承了该选择，分别验证配置意图和最终生效状态。

第一阶段成功发送65536字节，并校验服务器摘要。两端报告不同算法，但通信正常。客户端记录的基线拥塞窗口为五十六个段，观察时没有重传或未确认数据。这既证明名称无需相同，也在引入丢失前建立健康对照，避免把本来就无法通信的配置拿来解释后续过滤造成的结果。

随后目标安装输入规则，丢弃该连接的数据。客户端再发送16384字节，在确认不能返回时采样 TCP_INFO。重传超时后，内核进入丢失状态：本次窗口降至一个段，慢启动阈值变为二十八，重传计数增加。目标规则计数器确认确实丢弃了报文，支持这个故障归因，而不是仅从窗口下降猜测网络一定发生了什么。

移除规则后，同一连接恢复。客户端校验第二部分摘要，两个阶段共交付81920字节。最终窗口再次增长，累计重传反映恢复工作。这些是当前 Reno 超时场景的观察，不承诺所有控制器在任何丢失下都会将阈值减半或窗口降为一。应用正确交付与传输曾经经历恢复可以同时成立，不能互相否定。

测量与工作负载真正有关的限制

实验依据 Linux TCP_INFO 布局记录 MSS、拥塞窗口、阈值、RTT、未确认段与重传。这些窗口字段以段计数。一个快照不能单独建立吞吐量结论：应用可能没有数据可发，接收端可能限制进展，或者排队数据仍在等待发送。解释套接字诊断时应保留这些区别，避免把发送许可、实际占用和每秒完成数据量混为一谈。

运行环境变更应记录代表性套接字上的实际控制器，并在相关负载下比较延迟、吞吐、丢失与公平性。单条成功连接，不能证明存在竞争发送端或另一种瓶颈时仍有相同行为。本例隔离输入丢弃是受控故障，也不是互联网正常丢包率估计。选择算法的依据应来自应用需要和对应测量，而不是名字是否新颖或与对端一致。

将传输恢复证据与应用正确性一起观察。重传可以维护字节流，却增加完成时间，所以有效响应不意味着网络从未丢失。反过来，恢复期间窗口较小，也不直接代表连接已经损坏。有价值的结果，是验证交付，并根据真实观测解释发送端如何应对所遇条件。这样才能把正常退让、持续故障和应用自身限制分开处理。

来源

RFC 5681 Congestion Control，拥塞窗口与重传超时恢复，已核验 2026-09-12。
RFC 9438 CUBIC，CUBIC 行为及其与拥塞信号的关系，已核验 2026-09-12。
Linux tcp(7)，逐套接字选择拥塞控制器，已核验 2026-09-12。
Linux 6.12.76 TCP_INFO fields，拥塞状态、窗口、阈值与重传计数，已核验 2026-09-12。

HTTP/1.1 默认允许持久连接

Sat, 24 Oct 2026 00:00:00 +0000

持久连接允许多次请求和响应共享同一条连接，减少重复的 TCP 建立和 TLS 协商。但这是协议提供的能力，不是某个套接字永远可用的承诺。下一次请求能否真正复用，还取决于消息边界是否完整、客户端连接池策略、服务端行为和连接当前状态；单看请求成功或一次响应较快，都不足以证明走了复用路径。

默认允许，不代表永不关闭

HTTP/1.1 默认允许持久连接，客户端通常不需要发送 Connection: keep-alive 才能启用它。Connection: close 则表示当前交换之后不再继续使用这条连接。HTTP/1.0 的持久连接规则不同，不能把旧版本的协商方式复制到所有现代请求里，也不能把“没有 keep-alive 字段”直接判成配置错误。

复用首先需要明确的消息结束位置。准确的 Content-Length、分块编码，或无正文响应规则，都可以界定边界。若响应只能依靠关闭连接来表示结束，自然无法留下这条连接继续使用。接收方必须先消费完当前消息，再把后续字节解释成下一条；只收到 HTTP 200 状态，还不能证明响应正文已经完整到达。

已建立的 HTTPS 连接被复用时，不会重新进行 TLS 握手；使用缓存的 TLS 会话建立另一条连接，则仍然需要握手。TCP keepalive 又是另一回事，它的空闲探测不会刷新 HTTP 消息边界，也不能否定应用主动关闭连接的决定。HTTP/2 同样可以复用连接，但并不使用 HTTP/1.x 的 Connection 字段语义。

分别管理连接池与一次操作

空闲套接字仍占用描述符、缓冲区和实现相关的状态。Go 的 MaxIdleConnsPerHost 控制每个主机保留多少空闲连接，MaxConnsPerHost 则同时限制正在拨号、活动和空闲的连接总数。前者不是总并发上限。可复用连接池由共享的 Transport 持有，连续调用若各自建立无关的 transport，就会丢掉原本可以复用的连接资源。

IdleConnTimeout 限制一条空闲连接可以保留多久，Client.Timeout 则限制单次请求，包括获取连接和读取响应正文。两个计时边界不能混用。反向代理还分别持有下游与上游连接，因此浏览器到代理的复用和超时观察，不会自动说明代理到源站的连接池也采取相同策略；需要针对实际关心的那一跳取得证据。

坏掉的样子

客户端准备复用空闲连接时，服务器可能恰好关闭它。这类竞态必须能够处理，但连接重置不证明服务端没有执行操作。缺少业务层幂等约定时，自动重发一次有副作用的请求可能重复扣款或创建记录。增加空闲连接保留时间，不能消除这种“请求是否已经生效”的不确定性。

未消费的正文可能持续占用资源、推迟复用，或者导致连接关闭。应按照客户端库的契约完成或明确关闭每个响应。某些实现会自行排空被放弃的正文，但适用范围和大小限制各不相同，不能假设提前关闭就一定立即得到可复用连接。反过来，观察到一次复用失败，也不构成全局禁用持久连接的充分理由。

快速验证

以下 TLS 套接字集成原样保留，本轮没有重跑。文中的 macOS 观察属于历史记录，不是新一轮复用结果。

保存为 persistence_probe.go，使用 Go 1.23 或更新版本运行 go run persistence_probe.go。实验通过经过验证的 TLS 1.3 提供 HTTP/1.1 服务，为接受的 TCP 连接编号，并返回明确标注长度的两字节正文。它不修改公共服务或系统信任库；一个 transport 允许复用，另一个独立克隆则禁用复用。

package main

import (
 "context"
 "crypto/tls"
 "fmt"
 "io"
 "net"
 "net/http"
 "net/http/httptest"
 "net/http/httptrace"
 "runtime"
 "strconv"
 "sync/atomic"
 "time"
)

type connectionKey struct{}

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func main() {
 var accepted, handled atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 w.Header().Set("X-Connection-ID", fmt.Sprint(r.Context().Value(connectionKey{})))
 w.Header().Set("X-Request-Connection", r.Header.Get("Connection"))
 w.Header().Set("Content-Length", "2")
 if r.URL.Path == "/close" {
 w.Header().Set("Connection", "close")
 }
 fmt.Fprint(w, "ok")
 }))
 server.Config.ConnContext = func(ctx context.Context, _ net.Conn) context.Context {
 return context.WithValue(ctx, connectionKey{}, accepted.Add(1))
 }
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()
 config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{
 TLSClientConfig: config, MaxConnsPerHost: 1, IdleConnTimeout: 10 * time.Second,
 }
 defer transport.CloseIdleConnections()
 noReuse := transport.Clone()
 noReuse.DisableKeepAlives = true
 defer noReuse.CloseIdleConnections()
 probe := func(label, route string, tr *http.Transport, wantID int64, wantReuse bool) {
 var got atomic.Int64
 var reused atomic.Bool
 trace := &httptrace.ClientTrace{GotConn: func(info httptrace.GotConnInfo) {
 got.Add(1)
 reused.Store(info.Reused)
 }}
 request, err := http.NewRequest(http.MethodGet, server.URL+route, nil)
 must(err)
 request = request.WithContext(httptrace.WithClientTrace(request.Context(), trace))
 client := &http.Client{Transport: tr, Timeout: 2 * time.Second}
 response, err := client.Do(request)
 must(err)
 body, readError := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(readError)
 must(closeError)
 check(response.StatusCode == 200 && string(body) == "ok", "wrong response")
 check(response.Proto == "HTTP/1.1", "fixture requires HTTP/1.1")
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
 id, err := strconv.ParseInt(response.Header.Get("X-Connection-ID"), 10, 64)
 must(err)
 check(id == wantID && got.Load() == 1 && reused.Load() == wantReuse, "wrong connection reuse")
 check(response.Close == (route == "/close" || tr.DisableKeepAlives), "wrong close indication")
 wantHeader := ""
 if tr.DisableKeepAlives {
 wantHeader = "close"
 }
 check(response.Header.Get("X-Request-Connection") == wantHeader, "unexpected request Connection header")
 fmt.Printf("%s: conn=%d reused=%t closing=%t\n", label, id, reused.Load(), response.Close)
 }
 probe("cold", "/ok", transport, 1, false)
 probe("reuse", "/ok", transport, 1, true)
 probe("server close", "/close", transport, 1, true)
 probe("after server close", "/ok", transport, 2, false)
 transport.CloseIdleConnections()
 probe("after idle retirement", "/ok", transport, 3, false)
 probe("reuse disabled one", "/ok", noReuse, 4, false)
 probe("reuse disabled two", "/ok", noReuse, 5, false)
 check(accepted.Load() == 5 && handled.Load() == 7, "seven requests must use five TCP connections")
 fmt.Println(runtime.Version())
}

前三次请求都使用连接一，包括第三次明确告知服务端即将关闭的响应。因此，下一次请求使用连接二。随后主动回收空闲连接，会让再下一次请求建立连接三。禁用复用的 transport 则为它的两次请求分别建立连接四和连接五。总计七次应用请求，对应五条被服务端接受的 TCP 连接。

每次请求的 GotConn 事件还会核验复用标志。服务器回显收到的 Connection 字段：普通请求没有这个字段，却仍能复用套接字；禁用复用时，请求携带 close。这样验证的是实际连接、协议选择、证书检查、完整正文和关闭指示，而不是只查看内存中的配置值，就把配置存在当作行为生效。

已核验的 macOS、Go 1.27.0 运行通过全部断言。正文均读取完毕并关闭，每次请求限时两秒，两套 transport 也会清理。虽然设置了 IdleConnTimeout，但实验没有等待它到期，而是通过显式回收得到确定结果。它不测量提速、TLS 会话恢复、TCP 探活、流水线、生产资源上限或代理行为；这些结论仍需各自独立的测量支持。

来源

RFC 9112：HTTP/1.1，持久连接、消息边界、关闭和重试的规范依据，已核验 2026-10-15。
MDN：HTTP/1.x 连接管理，逐跳管理以及持久连接与流水线的区别，已核验 2026-10-15。
Go net/http，transport 连接池、连接数量限制、响应生命周期和超时语义，已核验 2026-10-15。

TCP · XB 现场笔记

TCP backlog 收纳还在握手中的连接

backlog 参数管的是 accept 队列

syncookies 开着的时候，SYN 队列就不再是瓶颈

压力真正落在 accept 队列上

坏掉的样子

快速验证

来源

TCP 慢启动随数据确认增长，不会仅因时间流逝而翻倍

坏掉的样子

快速验证

结合负载解释增长轨迹

来源

TCP 窗口缩放分别扩展两个方向的接收窗口编码

坏掉的样子

快速验证

区分缓冲分配、通告容量与实际性能

来源

Nagle 与延迟 ACK 可能让小请求的第二部分等待

坏掉的样子

快速验证

一起决定请求分帧与套接字策略

来源

SYN Cookie 在队列溢出时作答

两个队列，两种症状

Cookie 就是你拒绝保存的那份状态

Cookie 装不下的东西

坏掉的样子

快速验证

来源

listen backlog 保存等待 accept 的连接

坏掉的样子

快速验证

同时调整接受能力与等待容量

延伸阅读

来源

TCP 保活探测空闲连接

传输层探针不是应用心跳

配置真正承载请求的 socket

坏掉的样子

快速验证

延伸阅读

来源

SACK 报告缺口之后已收到的范围，帮助定位需要恢复的数据

坏掉的样子

快速验证

解释反馈时，不承诺重传判断绝对完美

来源

TCP 握手建立序列号空间，不是同步两台机器的时钟

坏掉的样子

快速验证

分别诊断建立过程和有效服务

来源

HTTP keep-alive：复用同一条连接

完整报文才允许复用

每一跳管理自己的超时

坏掉的样子

快速验证

延伸阅读

来源

调整 MSS 可以恢复一条 TCP 路径，却不会修复 MTU 反馈

坏掉的样子

快速验证

让变通措施对应实际包大小约束

来源

路径 MTU 发现失效时，握手和小请求仍可能成功

坏掉的样子

快速验证

按正确处理位置解释抓包

来源

TIME-WAIT 保护连接实例，不是独占一个端口号

坏掉的样子

快速验证

先减少无谓周转，再判断是否需要修改复用策略

来源

TCP 拥塞控制由每个发送端决定，两端可以使用不同算法

坏掉的样子

快速验证

测量与工作负载真正有关的限制

来源