【Linux 网络子系统深度拆解】分段卸载：GRO/GSO/TSO 的内核实现与陷阱

// include/linux/skbuff.h
struct skb_shared_info {
    // ... 其他字段
    unsigned short  gso_size;    /* 每个分段的 MSS（不含头部） */
    unsigned short  gso_segs;    /* 分段数量 */
    unsigned int    gso_type;    /* SKB_GSO_* 类型位图 */
    struct sk_buff  *frag_list;  /* GRO 聚合链 / GSO 分段链 */
    skb_frag_t      frags[];     /* page fragment 数组 */
};

// include/linux/skbuff.h
enum {
    SKB_GSO_TCPV4       = 1 << 0,   /* TCP/IPv4 分段 */
    SKB_GSO_DODGY       = 1 << 1,   /* 不可信来源（虚拟设备） */
    SKB_GSO_TCP_ECN     = 1 << 2,   /* ECN 感知 */
    SKB_GSO_TCP_FIXEDID = 1 << 3,   /* 固定 IP ID */
    SKB_GSO_TCPV6       = 1 << 4,   /* TCP/IPv6 分段 */
    SKB_GSO_FCOE        = 1 << 5,   /* FCoE */
    SKB_GSO_GRE         = 1 << 6,   /* GRE 隧道 */
    SKB_GSO_GRE_CSUM    = 1 << 7,   /* GRE + 校验和 */
    SKB_GSO_IPXIP4      = 1 << 8,   /* IP-in-IPv4 */
    SKB_GSO_IPXIP6      = 1 << 9,   /* IP-in-IPv6 */
    SKB_GSO_UDP_TUNNEL   = 1 << 10, /* UDP 隧道（VXLAN 等） */
    SKB_GSO_UDP_TUNNEL_CSUM = 1 << 11,
    SKB_GSO_PARTIAL     = 1 << 12,  /* 硬件只分段内层 L4 */
    SKB_GSO_TUNNEL_REMCSUM = 1 << 13,
    SKB_GSO_SCTP        = 1 << 14,  /* SCTP 分段 */
    SKB_GSO_ESP         = 1 << 15,  /* IPsec ESP */
    SKB_GSO_UDP_L4      = 1 << 16,  /* UDP 载荷分段 */
    SKB_GSO_FRAGLIST    = 1 << 17,  /* frag_list 聚合 */
};

// include/linux/netdev_features.h
// 设备能力标志（部分）
NETIF_F_TSO         // TCP IPv4 分段
NETIF_F_TSO6        // TCP IPv6 分段
NETIF_F_TSO_ECN     // ECN 感知 TSO
NETIF_F_GSO         // 软件 GSO
NETIF_F_GRO         // 软件 GRO
NETIF_F_GRO_HW      // 硬件 GRO
NETIF_F_LRO         // Large Receive Offload（已废弃）
NETIF_F_GSO_PARTIAL // 部分硬件卸载
NETIF_F_GSO_UDP_L4  // UDP 载荷 GSO

// include/net/gro.h / net/core/gro.c
gro_result_t napi_gro_receive(struct napi_struct *napi,
                              struct sk_buff *skb)
{
    // 1. 计算 skb 哈希
    // 2. 在 napi->gro_hash[bucket] 中查找同流 skb
    // 3. 找到 → skb_gro_receive() 聚合
    // 4. 未找到 → 新建链表项
    // 5. 超过 MAX_GRO_SKBS → flush 最旧的
}

// include/linux/netdevice.h
#define GRO_HASH_BUCKETS  8

struct gro_list {
    struct list_head  list;
    int               count;
};

struct napi_struct {
    // ...
    struct gro_list   gro_hash[GRO_HASH_BUCKETS];
    // ...
};

// include/net/gro.h
struct napi_gro_cb {
    void      *frag0;          /* 第一个 fragment 的虚拟地址 */
    unsigned int frag0_len;    /* frag0 可用长度 */
    int       data_offset;     /* 当前层的数据偏移 */
    u16       flush;           /* 非零则不聚合，直接递交 */
    u16       flush_id;        /* IP ID 连续性校验 */
    u16       count;           /* 已聚合的分段数 */
    u16       proto;           /* 传输层协议 */

    unsigned long age;         /* 进入 GRO 的时间戳 */

    /* 位域 */
    u16       same_flow:1,     /* 与已有条目属同一流 */
              encap_mark:1,    /* 经过隧道解封装 */
              csum_valid:1,    /* 硬件校验和已验证 */
              csum_cnt:3,      /* 待验证的校验和层数 */
              is_flist:1,      /* frag_list 模式聚合 */
              recursion_counter:4; /* 隧道嵌套深度限制 */
};

// net/ipv4/tcp_offload.c (概念性)
static struct sk_buff *tcp4_gro_receive(struct list_head *head,
                                        struct sk_buff *skb)
{
    // 检查源/目的端口、序号连续性
    // 检查 TCP 标志：PSH/FIN/RST/SYN 中任一置位 → flush
    // 检查窗口大小是否变化
    // 检查 TCP 选项（timestamp）是否兼容
    // 通过 → same_flow = 1
}

// net/core/skbuff.c
int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb)
{
    struct skb_shared_info *pinfo = skb_shinfo(p);
    struct skb_shared_info *skbinfo = skb_shinfo(skb);

    // 策略 1：page fragment 追加
    // 如果 p 的 frags[] 还有空间，直接把 skb 的数据页追加
    // 这是零拷贝路径，最高效

    // 策略 2：frag_list 链接
    // 如果 frags[] 满或数据在 linear 区域
    // 把 skb 挂到 p->frag_list 链表

    // 更新元数据
    p->len += skb->len;
    p->data_len += skb->len;
    p->truesize += skb->truesize;
    NAPI_GRO_CB(p)->count++;

    return 0;
}

// net/core/dev.c (概念性)
static int __dev_queue_xmit(struct sk_buff *skb, ...)
{
    // ...
    if (netif_needs_gso(skb, features)) {
        // 硬件不支持该 GSO 类型 → 软件分段
        skb = __skb_gso_segment(skb, features, tx_path);
    }
    // ...
}

// include/linux/netdevice.h
static inline bool netif_needs_gso(struct sk_buff *skb,
                                   netdev_features_t features)
{
    return skb_is_gso(skb) &&              // 包标记了 GSO
           (!skb_gso_ok(skb, features) ||  // 硬件不支持该类型
            unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
}

// net/core/gso.c
struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
                                  netdev_features_t features,
                                  bool tx_path)
{
    struct sk_buff *segs;

    // 1. 克隆 skb（保留原件用于错误回退）
    // 2. 调用协议层回调 gso_segment
    segs = skb_mac_gso_segment(skb, features);
    // → inet_gso_segment()
    //   → tcp4_gso_segment()

    return segs;  // 返回分段链表
}

// net/ipv4/tcp_offload.c (概念性)
struct sk_buff *tcp4_gso_segment(struct sk_buff *skb,
                                 netdev_features_t features)
{
    unsigned int mss = skb_shinfo(skb)->gso_size;

    // 按 mss 拆分数据：
    // 1. 每 mss 字节创建一个新 skb
    // 2. 每个 skb 独立设置 TCP 头（序号、校验和）
    // 3. 每个 skb 独立设置 IP 头（ID、长度、校验和）
    // 4. 返回 skb 链表（通过 skb->next 链接）
}

// 驱动声明支持 PARTIAL
dev->hw_features |= NETIF_F_GSO_PARTIAL;
dev->gso_partial_features = NETIF_F_GSO_GRE |
                            NETIF_F_GSO_UDP_TUNNEL;

// 用户态通过 cmsg 指定分段大小
struct msghdr msg;
int gso_size = 1472;  // UDP 载荷大小
// 设置 UDP_SEGMENT cmsg
// 发送 N * gso_size 字节

// 内核路径：
// udp_sendmsg() → 创建大 skb
//   gso_type = SKB_GSO_UDP_L4
//   gso_size = 1472
// dev_queue_xmit() → 软件/硬件分段

// net/ipv4/tcp_output.c (概念性)
static int tcp_write_xmit(struct sock *sk, unsigned int mss_now,
                           int nonagle, int push_one, gfp_t gfp)
{
    // mss_now = TCP MSS（通常 1460）
    // tso_segs = min(skb->len / mss_now, tso_max_segs)

    while ((skb = tcp_send_head(sk))) {
        unsigned int limit = tcp_mss_split_point(sk, skb, mss_now,
                                                  nonagle, cwnd);
        // limit 可远大于 mss_now（受 cwnd、TSQ 限制）

        // 设置 GSO 元数据
        skb_shinfo(skb)->gso_size = mss_now;
        skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss_now);
        skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;  // 或 TCPV6

        tcp_transmit_skb(sk, skb, ...);
    }
}

// include/linux/netdevice.h
struct net_device {
    unsigned int   gso_max_size;      /* 通用 GSO/TSO 最大字节数 */
    unsigned int   gso_ipv4_max_size; /* IPv4 专用限制 */
    u16            gso_max_segs;      /* 单个 GSO 包最大分段数 */
    u16            tso_max_size;      /* TSO 专用限制 */
    u16            tso_max_segs;      /* TSO 最大分段数 */
};

// 驱动通过以下 API 声明限制
netif_set_tso_max_size(dev, 65536);
netif_set_tso_max_segs(dev, 64);

// TCP Small Queues (TSQ)
// net/ipv4/tcp_output.c
// 限制每个 socket 在 qdisc + 驱动队列中的数据量
sysctl_tcp_limit_output_bytes  // 默认 2 × 64KB

// FQ qdisc pacing
// net/sched/sch_fq.c
// 根据 sk->sk_pacing_rate 控制发送时机
// 每个 TCP 流独立 pacing

# 推荐配置：TSO + FQ pacing
tc qdisc replace dev eth0 root fq
ethtool -K eth0 tso on gso on

// include/net/gro_cells.h
struct gro_cells {
    struct gro_cell __percpu *cells;
};

struct gro_cell {
    struct sk_buff_head  napi_skbs;
    struct napi_struct   napi;
};

# VXLAN 封装增加 50 字节开销
# 内层 MTU 1450，但 GRO 聚合后内层包可达 65536
# 如果物理网卡不支持隧道 TSO，软件 GSO 按内层 MTU 分段
# 每个分段都要独立封装外层头 → CPU 开销倍增

# 内层 TCP 校验和 → CHECKSUM_PARTIAL（硬件计算）
# 外层 UDP 校验和 → 取决于网卡能力
# 不匹配时回退到软件校验 → 性能下降
ethtool -k eth0 | grep tx-udp_tnl-segmentation

# 查看 qdisc 是否正确处理 GSO
tc -s qdisc show dev eth0
# 如果看到 backlog 中有超大包，可能是 GSO 未分段

# 推荐：fq_codel 作为叶子 qdisc
tc qdisc replace dev eth0 root handle 1: htb default 10
tc class add dev eth0 parent 1: classid 1:10 htb rate 100mbit
tc qdisc add dev eth0 parent 1:10 fq_codel

# 查看设备 offload 能力
ethtool -k eth0 | grep -E '(generic-receive-offload|generic-segmentation|tcp-segmentation|large-receive)'
# generic-receive-offload: on       → GRO
# generic-segmentation-offload: on  → GSO
# tcp-segmentation-offload: on      → TSO
# large-receive-offload: off        → LRO（应保持关闭）

# 查看隧道 offload
ethtool -k eth0 | grep tunnel
# tx-udp_tnl-segmentation: on
# tx-udp_tnl-csum-segmentation: on

# 查看 GSO 最大值
cat /sys/class/net/eth0/gso_max_size
cat /sys/class/net/eth0/gro_max_size
cat /sys/class/net/eth0/tso_max_size

# 追踪 GRO 聚合后的分段数分布
bpftrace -e '
kprobe:napi_gro_complete {
    $skb = (struct sk_buff *)arg1;
    $shinfo = (struct skb_shared_info *)($skb->head + $skb->end);
    @gro_segs = hist($shinfo->gso_segs);
}
'

# 追踪 GRO flush 原因
bpftrace -e '
kprobe:napi_gro_flush {
    @flush_count = count();
}
kprobe:napi_gro_receive {
    @receive_count = count();
}
interval:s:1 {
    printf("GRO receive: %lld, flush: %lld, ratio: ",
           @receive_count, @flush_count);
    print(@gro_segs);
    clear(@receive_count);
    clear(@flush_count);
}
'

# 追踪软件 GSO 分段事件（应尽量少，说明硬件 TSO 在工作）
bpftrace -e '
kprobe:__skb_gso_segment {
    $skb = (struct sk_buff *)arg0;
    @gso_segment_count = count();
    @gso_segment_dev[str($skb->dev->name)] = count();
}
interval:s:5 {
    print(@gso_segment_count);
    print(@gso_segment_dev);
    clear(@gso_segment_count);
    clear(@gso_segment_dev);
}
'

# 对比开启/关闭 TSO 的 CPU 开销
ethtool -K eth0 tso off
perf stat -e cycles,instructions -a -- sleep 10
# 记录关闭 TSO 时的 cycles

ethtool -K eth0 tso on
perf stat -e cycles,instructions -a -- sleep 10
# 对比开启 TSO 时的 cycles

# GRO 开销分析
perf record -g -a -e cycles -- sleep 10
perf report --no-children | grep -E '(gro_receive|gro_complete|gso_segment)'

# 统计 GRO 递交包的大小分布
bpftrace -e '
kprobe:netif_receive_skb_list_internal {
    // 这是 GRO flush 后的路径
}
kprobe:netif_receive_skb_core {
    $skb = (struct sk_buff *)arg0;
    @pkt_len = hist($skb->len);
}
interval:s:10 {
    print(@pkt_len);
    clear(@pkt_len);
}
'

ethtool -K eth0 tso on gso on gro on
echo 524280 > /sys/class/net/eth0/gro_max_size
sysctl -w net.core.gro_flush_timeout=20000
sysctl -w net.core.napi_defer_hard_irqs=10

ethtool -K eth0 tso on gso on gro on
echo 65536 > /sys/class/net/eth0/gro_max_size  # 保守聚合
sysctl -w net.core.gro_flush_timeout=0           # 不额外等待
sysctl -w net.core.napi_defer_hard_irqs=0

ethtool -K eth0 tso on gso on gro on lro off
# 确保 LRO 关闭！GRO + GSO 组合才能正确转发
# 检查隧道 TSO 支持
ethtool -k eth0 | grep tnl