Linux TSO流程分析

最新推荐文章于 2026-04-06 22:45:17 发布

原创

最新推荐文章于 2026-04-06 22:45:17 发布 · 5.6k 阅读

本文深入解析TSO（Transmit Segment Offload）与GSO（Generic Segmentation Offload）的工作原理，阐述它们如何提高网络数据包处理效率，特别是在虚拟网卡环境下。详细介绍了TSO在驱动初始化、GSO能力注册、连接建立、数据发送、 skb分段处理等关键流程中的作用，以及硬件TSO支持下的数据包分段和checksum计算优化。

1、TSO(transimit segment offload)是针对tcp而言的，是指协议栈可以将tcp 分段的操作offload到硬件的能力，本身需要硬件的支持。当网卡具有TSO能力时，上层协议栈可以直接下发一个超过MTU数据包，而把数据包拆分的动作交给硬件去做，节省cpu资源。除了TSO，内核还有一个GSO，GSO不区分协议类型，GSO默认是开启的，GSO是在软件上实现的一种延迟分段的技术，相比TSO，GSO最终还是需要协议栈自己完成分段的处理。

即使网卡没有TSO能力，传输层依然可以封装一个超过MTU的数据包，等数据包发送给驱动之前，检查网卡是否有TSO能力，如果没有，再调用ip层和传输层的分段处理函数完成数据包的分段处理，通过这样，内核将数据包的分段延迟到了dev链路层，提升数据包处理效率。当支持GSO/TSO时，skb的数据存放格式如下所示，在skb->end后，存在一个skb_share区域，skb的非线性区数据就存放在这里，GSO/TSO分段的处理就是要把skb数据（包括线性区、非线性区）按gso_size的大小进行分割处理；本文以虚拟网卡为例，介绍TSO的整体流程。

2、驱动初始化过程

virtio驱动加载时，会根据qemu/vhost前后端feature协商的结果判断虚拟网卡是否有TSO能力，如果有，则在dev->hw_feature或上NETIF_F_TSO标志，然后赋给dev->features。

static int virtnet_probe(struct virtio_device *vdev)
{
		/* Individual feature bits: what can host handle? */
		if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
			dev->hw_features |= NETIF_F_TSO;

                //gso默认为True
		if (gso)
			dev->features |= dev->hw_features & (NETIF_F_ALL_TSO|NETIF_F_UFO);
}

3、注册虚拟网卡设备时，设置GSO能力。

virtnet_probe ---> register_netdev ---->register_netdevice

int register_netdevice(struct net_device *dev)
{
	dev->hw_features |= NETIF_F_SOFT_FEATURES;
        //dev->features是给协议栈用的
	dev->features |= NETIF_F_SOFT_FEATURES;
}

4、在发送端发起connect连接或三次握手建立完成（tcp_v4_syn_recv_sock），会开启GSO。

int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
	rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
			       inet->inet_sport, inet->inet_dport, sk);
	if (IS_ERR(rt)) {
		err = PTR_ERR(rt);
		rt = NULL;
		goto failure;
	}
	/* OK, now commit destination to socket.  */
        //设置GSO类型为tcpv4
	sk->sk_gso_type = SKB_GSO_TCPV4;
	sk_setup_caps(sk, &rt->dst);
}

tcp_v4_connect将sock的gso_type设置为tcpv4类型，然后调用sk_setup_caps，根据net_gso_ok返回值，判断是否支持GSO能力，正常这里是返回True。

static inline bool net_gso_ok(netdev_features_t features, int gso_type)
{
        //这个函数可以认为是检验是否具有tso能力，主要的调用地方有两个:
        //1、tcp层connect或三次握手完成时调用，这个调用流程里，如果开启GSO，则features同时会置上TSO，
        //   而GSO默认都是开启的，因此tcp层调用这个接口，会返回true
        //2、dev层将skb发送给驱动前调用，判断是否需要做TSO，这个调用流程里，features直接等于dev->features，
        //   如果网卡没有TSO能力，则features不会有TSO的标志，那这个函数就会返回false
    
	netdev_features_t feature = gso_type & SKB_GSO1_MASK;

	feature <<= NETIF_F_GSO_SHIFT;

	if (gso_type & SKB_GSO2_MASK) {
		netdev_features_t f = gso_type & SKB_GSO2_MASK;
		f <<= NETIF_F_GSO2_SHIFT;
		feature |= f;
	}

	/* check flags correspondence */
	BUILD_BUG_ON(SKB_GSO_TCPV4   != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP     != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_DODGY   != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCPV6   != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_FCOE    != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_GRE     != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_IPIP    != (NETIF_F_GSO_IPIP >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_SIT     != (NETIF_F_GSO_SIT >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
	BUILD_BUG_ON(SKB_GSO_MPLS    != (NETIF_F_GSO_MPLS >> NETIF_F_GSO_SHIFT));

	/* GSO2 flags, see netdev_features.h */
	BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_SCTP    != (NETIF_F_GSO_SCTP >> NETIF_F_GSO2_SHIFT));
	BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO2_SHIFT));

	return (features & feature) == feature;
}

协议层校验支持gso后，会同时开启分散、聚合及csum校验能力。

void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
{
	sk_dst_set(sk, dst);
	sk->sk_route_caps = dst->dev->features;
	if (sk->sk_route_caps & NETIF_F_GSO)
		sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
	sk->sk_route_caps &= ~sk->sk_route_nocaps;
	if (sk_can_gso(sk)) {
		//skb头部需要额外空间，关闭GSO
		if (dst->header_len) {
			sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
		} else {
			//开启skb的分散、聚合及csum功能，因为网卡做TSO的同时需要支持分散、聚合功能以及csum的重新计算能力
			sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
			sk->sk_gso_max_size = dst->dev->gso_max_size;
			sk->sk_gso_max_segs = dst->dev->gso_max_segs;
		}
	}
}

5、应用程序调用send发送数据包，send系统调用最终调用tcp_sendmsg，在tcp_sendmsg里判断是否支持GSO，支持的话将用户数据信息封装到skb的线性区或非线性区，封装完后的skb数据包就是一个大包了，然后调用tcp_push_one发送给IP层，当然发送之前还会调用check函数，根据csum的类型计算tcp层的csum，支持GSO、TSO情况下，tcp层只会计算伪头部的csum。

int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		size_t size)
{
	struct iovec *iov;
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;
	int iovlen, flags, err, copied = 0;
	int mss_now = 0, size_goal, copied_syn = 0, offset = 0;
	bool sg;
	long timeo;

	lock_sock(sk);

	flags = msg->msg_flags;
	if (flags & MSG_FASTOPEN) {
		err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size);
		if (err == -EINPROGRESS && copied_syn > 0)
			goto out;
		else if (err)
			goto out_err;
		offset = copied_syn;
	}

	timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT)