协议栈 IP 层主体流程

IP 层主要的工作是头部验证，头部选项的处理，分片和重组，以及路由，本篇文章主要分析 IP 层的主体流程，路由和分片的具体细节暂时略解。

在 ip_init 注册 ip_rcv 处理函数，然后初始化路由子系统，和对端管理器。两个结构 ip_tstamps 和 ip_idents。ip_rcv 是 IP 的入口，主要是一些参数检查。

/*
 * 	Main IP Receive routine.
 */
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
{
	const struct iphdr *iph;
	struct net *net;
	u32 len;

	/* When the interface is in promisc. mode, drop all the crap
	 * that it receives, do not try to analyse it.
	 */
	 // 如果 L2 地址不是本机地址 pkt_type 就会被设置成 PACKET_OHTERHOST
	 // 然后进行丢包
	if (skb->pkt_type == PACKET_OTHERHOST)
		goto drop;


	net = dev_net(dev);
	__IP_UPD_PO_STATS(net, IPSTATS_MIB_IN, skb->len);
	// 检查引用计数，如果有人引用就复制一份自己的 skb。
	skb = skb_share_check(skb, GFP_ATOMIC);
	if (!skb) {
		__IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
		goto out;
	}
	// 保证有 iphdr 大小，如果没有，则可能尝试从 skb_shinfo(skb)->frags[] 中获取
	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
		goto inhdr_error;

	iph = ip_hdr(skb);

	/*
	 *	RFC1122: 3.2.1.2 MUST silently discard any IP frame that fails the checksum.
	 *
	 *	Is the datagram acceptable?
	 *
	 *	1.	Length at least the size of an ip header
	 *	2.	Version of 4
	 *	3.	Checksums correctly. [Speed optimisation for later, skip loopback checksums]
	 *	4.	Doesn't have a bogus length
	 */
	// ip 头部长度至少 20 个字节
	if (iph->ihl < 5 || iph->version != 4)
		goto inhdr_error;

	BUILD_BUG_ON(IPSTATS_MIB_ECT1PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_1);
	BUILD_BUG_ON(IPSTATS_MIB_ECT0PKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_ECT_0);
	BUILD_BUG_ON(IPSTATS_MIB_CEPKTS != IPSTATS_MIB_NOECTPKTS + INET_ECN_CE);
	__IP_ADD_STATS(net,
		       IPSTATS_MIB_NOECTPKTS + (iph->tos & INET_ECN_MASK),
		       max_t(unsigned short, 1, skb_shinfo(skb)->gso_segs));
	// 保证完整的头部大小
	if (!pskb_may_pull(skb, iph->ihl*4))
		goto inhdr_error;

	iph = ip_hdr(skb);
	// 做校验和
	if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
		goto csum_error;
	// 保证 skb buffer 的大小比 packet 长度大，不然就丢包
    // 这个原因是 L2 有 padding? (TODO)
    // 并且 packet 长度至少有头部那么大
	len = ntohs(iph->tot_len);
	if (skb->len < len) {
		__IP_INC_STATS(net, IPSTATS_MIB_INTRUNCATEDPKTS);
		goto drop;
	} else if (len < (iph->ihl*4))
		goto inhdr_error;

	/* Our transport medium may have padded the buffer out. Now we know it
	 * is IP we can trim to the true length of the frame.
	 * Note this now means skb->len holds ntohs(iph->tot_len).
	 */
	if (pskb_trim_rcsum(skb, len)) {
		__IP_INC_STATS(net, IPSTATS_MIB_INDISCARDS);
		goto drop;
	}

	skb->transport_header = skb->network_header + iph->ihl*4;

	/* Remove any debris in the socket control block */
	memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
	IPCB(skb)->iif = skb->skb_iif;

	/* Must drop socket now because of tproxy. */
	skb_orphan(skb);

	return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
		       net, NULL, skb, dev, NULL,
		       ip_rcv_finish);

csum_error:
	__IP_INC_STATS(net, IPSTATS_MIB_CSUMERRORS);
inhdr_error:
	__IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);
drop:
	kfree_skb(skb);
out:
	return NET_RX_DROP;
}

但实际上，大部分的函数是分成两部分的，真正的行为都在 _finish 后缀当中，前期都是检查。在 netfilter 里面 NF_HOOK 这个宏是有个 okfn 如果通过了 netfilter 的检查就会调用这个函数。对应的就是 ip_rcv_finish 当中，要决定是否继续向上层传递还是要进行找到出口设备确定下一跳，进行转发。如果是从设备就交给主设备的 handler 处理（这个和 VRF 有关，主设备代表这些从设备表示的一个域，用于分配一个专有的 FIB 表等等，类似某种程度的隔离）。

/* if ingress device is enslaved to an L3 master device pass the
 * skb to its handler for processing
 */
skb = l3mdev_ip_rcv(skb);
if (!skb)
	return NET_RX_SUCCESS;

如果设置了 ip_early_demux 并且不是分片的 IP 包，就会提前调用 TCP 的 early_demux 提前解复用这个包。

if (net->ipv4.sysctl_ip_early_demux &&
    !skb_dst(skb) &&
    !skb->sk &&
    !ip_is_fragment(iph)) {
	const struct net_protocol *ipprot;
	int protocol = iph->protocol;

	ipprot = rcu_dereference(inet_protos[protocol]);
	if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) {
		edemux(skb);
		/* must reload iph, skb->head might have changed */
		iph = ip_hdr(skb);
	}
}

在路由系统中找到 dst 指向的 dst_entry，接下来的处理函数也会存在 dst 当中，为一下三种。

• ip_forward() 转发到其他主机
• ip_local_deliver() 传入传输层
• ip_error() 出现了错误，可能会发送一个 ICMP

/*
 *	Initialise the virtual path cache for the packet. It describes
 *	how the packet travels inside Linux networking.
 */
if (!skb_valid_dst(skb)) {
	int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
				       iph->tos, dev);
	if (unlikely(err)) {
		if (err == -EXDEV)
			__NET_INC_STATS(net, LINUX_MIB_IPRPFILTER);
		goto drop;
	}
}

如果编译选项带了 CONFIG_IP_ROUTE_CLASSID 那么有流量控制的 classid 的就会进行一些统计。

#ifdef CONFIG_IP_ROUTE_CLASSID
	if (unlikely(skb_dst(skb)->tclassid)) {
		struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
		u32 idx = skb_dst(skb)->tclassid;
		st[idx&0xFF].o_packets++;
		st[idx&0xFF].o_bytes += skb->len;
		st[(idx>>16)&0xFF].i_packets++;
		st[(idx>>16)&0xFF].i_bytes += skb->len;
	}
#endif

首先如果 IP 头部长度大于 5 说明有 options，调用 ip_rcv_options 进行处理，如果失败了就进行丢包。

if (iph->ihl > 5 && ip_rcv_options(skb))
	goto drop;

具体过程在 ip_rcv_options 当中。

if (skb_cow(skb, skb_headroom(skb))) {
	__IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INDISCARDS);
	goto drop;
}

首先把 skb_headroom 等于 skb->data - skb->head，计算了头部的长度，如果这个头部有 clone 就会被复制一份来 declone。

然后根据把 IP option 存进结构化的 inet_skb_parm 当中，其中有个成员是 struct ip_options 。IPCB

代表的是 #define IPCB(skb) ((struct inet_skb_parm*)((skb)->cb))，skb->cb 是一个缓冲区用于协议栈每层的处理函数存放一些临时的私有变量。

iph = ip_hdr(skb);
opt = &(IPCB(skb)->opt);
opt->optlen = iph->ihl*4 - sizeof(struct iphdr);

if (ip_options_compile(dev_net(dev), opt, skb)) {
	__IP_INC_STATS(dev_net(dev), IPSTATS_MIB_INHDRERRORS);
	goto drop;
}

in_device 是和 IP 有关的设备信息，如果没有 source route 选项就直接跳过，不然处理 source route 选项。

if (unlikely(opt->srr)) {
	struct in_device *in_dev = __in_dev_get_rcu(dev);

	if (in_dev) {
		if (!IN_DEV_SOURCE_ROUTE(in_dev)) {
			if (IN_DEV_LOG_MARTIANS(in_dev))
				net_info_ratelimited("source route option %pI4 -> %pI4\n",
						     &iph->saddr,
						     &iph->daddr);
			goto drop;
		}
	}

	if (ip_options_rcv_srr(skb))
		goto drop;
}

source route 是一个多字节选项。此选项中，发送节点会列出后续几跳的 IP 地址（不能超过 IP 报头的最大长度）。如果列表中有某台主机宕机了，则必须重新计算来源地路由，重新发送，而不是使用动态路由。ip_options_rcv_srr 的具体工作就是根据提取出的目的地在本地计算目的地是否可达，如果成功就反回 0， 不然就丢弃。

从ip_rcv_options 出来以后根据组播广播进行数据统计。下面的 IN_DEV_ORCONF 不太确定是啥 (TODO)。

rt = skb_rtable(skb);
if (rt->rt_type == RTN_MULTICAST) {
	__IP_UPD_PO_STATS(net, IPSTATS_MIB_INMCAST, skb->len);
} else if (rt->rt_type == RTN_BROADCAST) {
	__IP_UPD_PO_STATS(net, IPSTATS_MIB_INBCAST, skb->len);
} else if (skb->pkt_type == PACKET_BROADCAST ||
	   skb->pkt_type == PACKET_MULTICAST) {
	struct in_device *in_dev = __in_dev_get_rcu(dev);

	/* RFC 1122 3.3.6:
	 *
	 *   When a host sends a datagram to a link-layer broadcast
	 *   address, the IP destination address MUST be a legal IP
	 *   broadcast or IP multicast address.
	 *
	 *   A host SHOULD silently discard a datagram that is received
	 *   via a link-layer broadcast (see Section 2.4) but does not
	 *   specify an IP multicast or broadcast destination address.
	 *
	 * This doesn't explicitly say L2 *broadcast*, but broadcast is
	 * in a way a form of multicast and the most common use case for
	 * this is 802.11 protecting against cross-station spoofing (the
	 * so-called "hole-196" attack) so do it for both.
	 */
	if (in_dev &&
	    IN_DEV_ORCONF(in_dev, DROP_UNICAST_IN_L2_MULTICAST))
		goto drop;
}

return dst_input(skb);

进入 dst_input 就会交给 skb­>dst ­>input 来处理。

转发会分成两部分处理 ip_forward 和 ip_forward_finish IP 转发分成几个步骤

1. 处理 IP options，可能会要求记录本地 IP 地址和时间戳
2. 基于 IP 头，确保这个 pakcet 可以发出去
3. 减 1 TTL，到达 0 就丢弃
4. 根据 MTU 进行分组
5. 发送至出口设备

期间如果出错了，会通过 ICMP 告知。xfrm4_xxx 是 IPsec 相关的函数。

if (IPCB(skb)->opt.router_alert && ip_call_ra_chain(skb))
	return NET_RX_SUCCESS;

首先是检查 IP 选项当中有没有 Router Alert，如果有的话就交给 ip_ra_chain 中对此感兴趣的 raw socket 来处理，并且就次结束。

在这里检查 TTL 是否耗尽

if (ip_hdr(skb)->ttl <= 1)
	goto too_many_hops;

如果是严格的源路由，下一条是网关而不是直接连接的路由就丢包。

rt_uses_gateway 代表两种意思

• 1 的时候表示网关
• 0 的时候表示直接路由

if (opt->is_strictroute && rt->rt_uses_gateway)
	goto sr_failed;

如果超出 MTU 进行丢包

IPCB(skb)->flags |= IPSKB_FORWARDED;
mtu = ip_dst_mtu_maybe_forward(&rt->dst, true);
if (ip_exceeds_mtu(skb, mtu)) {
	IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
		  htonl(mtu));
	goto drop;
}

declone 这个 skb 并且确保预留 L2 的空间，然后减少 TTL。

/* We are about to mangle packet. Copy it! */
if (skb_cow(skb, LL_RESERVED_SPACE(rt->dst.dev)+rt->dst.header_len))
	goto drop;
iph = ip_hdr(skb);

/* Decrease ttl after skb cow done */
ip_decrease_ttl(iph);

如果被标记为 IPSKB_DOREDIRECT 发送 redirect ICMP，接着设置优先级。

/*
 *	We now generate an ICMP HOST REDIRECT giving the route
 *	we calculated.
 */
if (IPCB(skb)->flags & IPSKB_DOREDIRECT && !opt->srr &&
    !skb_sec_path(skb))
	ip_rt_send_redirect(skb);

skb->priority = rt_tos2priority(iph->tos);

然后进入 ip_forward_finish

return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
	       net, NULL, skb, skb->dev, rt->dst.dev,
	       ip_forward_finish);

在 ip_forward_finish 当中会进入 dst_output，ip_forward_options 会处理一些 IP 选项并且重新计算 IP 头的校验和。

if (unlikely(opt->optlen))
	ip_forward_options(skb);

return dst_output(net, sk, skb);

在内部有两种情况，一种是单播，一种是广播，对应的处理函数分别是 ip_output 喝 ip_mc_output 两种处理函数，会进行分组操作，然后在 ip_finish_output 当中进入邻居系统。

skb_dst(skb)->output(net, sk, skb);

ip_local_deliver 主要的工作是对分片进行重组。

int ip_local_deliver(struct sk_buff *skb)
{
	/*
	 *	Reassemble IP fragments.
	 */
	struct net *net = dev_net(skb->dev);

	if (ip_is_fragment(ip_hdr(skb))) {
		if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
			return 0;
	}

	return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
		       net, NULL, skb, skb->dev, NULL,
		       ip_local_deliver_finish);
}

这是 3 层接收端的一个大体结构，下面看一下 3 层发送端的一些内容。发送的入口

int ip_queue_xmit(struct sk_buff *skb, int ipfragok)

首先会检查是否已经有了路由信息，这个在 SCTP 的情况下会发生。

rt = skb_rtable(skb);
if (rt)
	goto packet_routed;

检查是否缓存了 route 如果有的话却是路由信息的有效性

/* Make sure we can route this packet. */
rt = (struct rtable *)__sk_dst_check(sk, 0);

ip_route_output_ports 确保 source route list 的 下一跳和 daddr 一致，并且将路由设置在 skb 里面。

if (!rt) {
	__be32 daddr;

	/* Use correct destination address if we have options. */
	daddr = inet->inet_daddr;
	if (inet_opt && inet_opt->opt.srr)
		daddr = inet_opt->opt.faddr;

	/* If this fails, retransmit mechanism of transport layer will
	 * keep trying until route appears or the connection times
	 * itself out.
	 */
	rt = ip_route_output_ports(net, fl4, sk,
				   daddr, inet->inet_saddr,
				   inet->inet_dport,
				   inet->inet_sport,
				   sk->sk_protocol,
				   RT_CONN_FLAGS(sk),
				   sk->sk_bound_dev_if);
	if (IS_ERR(rt))
		goto no_route;
	sk_setup_caps(sk, &rt->dst);
}
skb_dst_set_noref(skb, &rt->dst);

接下来就需要构建 IP 头了，先调用空出需要的 IP 头部空间，并且重置我的大脑。

/* OK, we know where to send it, allocate and build IP header. */
skb_push(skb, sizeof(struct iphdr) + (inet_opt ? inet_opt->opt.optlen : 0));

重置 IP 头长度其实就是设置了 network_header 等于 data - head

skb_reset_network_header(skb);

转换成 16 位的指针并且把 IP 协议号，IP 头长度，inet->tos TOS 写入。

iph = ip_hdr(skb);
*((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));

初始化 iph

if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)
	iph->frag_off = htons(IP_DF);
else
	iph->frag_off = 0;
iph->ttl      = ip_select_ttl(inet, &rt->dst);
iph->protocol = sk->sk_protocol;
ip_copy_addrs(iph, fl4);

如果有选项长度更新选项长度

/* Transport layer set skb->h.foo itself. */

if (inet_opt && inet_opt->opt.optlen) {
	iph->ihl += inet_opt->opt.optlen >> 2;
	ip_options_build(skb, &inet_opt->opt, inet->inet_daddr, rt, 0);
}

基于是否分片给 packet 分配 ID，然后进入 ip_local_out

ip_select_ident_segs(net, skb, sk,
		     skb_shinfo(skb)->gso_segs ?: 1);

/* TODO : should we use skb->sk here instead of sk ? */
skb->priority = sk->sk_priority;
skb->mark = sk->sk_mark;

res = ip_local_out(net, sk, skb);

当这里先告一段落，再来看一下 ip_append_data 这个函数的作用是缓存进合理的结构以便之后进行分片然后发送。ip_push_pending_frames 就可以触发这个动作。

int ip_append_data(struct sock *sk, struct flowi4 *fl4,
		   int getfrag(void *from, char *to, int offset, int len,
			       int odd, struct sk_buff *skb),
		   void *from, int len, int protolen,
		   struct ipcm_cookie *ipc,
		   struct rtable **rt,
		   unsigned int flags);

第一件事情，检查是否有 MSG_PROBE 的标志，有了这个标志的话，表示请求并不真的是需要向下调用。这个在测试对应 IP 地址的 PMTU 的时候会用到。

if (flags&MSG_PROBE)
	return 0;

如果 sock 相关联的 sk_write_queue 队列为空，说明这个是第一个 IP fragment ，如果不是第一个那么就把 transhdrlen 设置成 0，因为只有第一个 IP fragment 才有头部长度的信息。

if (skb_queue_empty(&sk->sk_write_queue)) {
	err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
	if (err)
		return err;
} else {
	transhdrlen = 0;
}

ip_setup_cork 主要是初始化了 net->cork，cork 保存了 IP options 和 路由信息。

进入 __append_ip_data 之后可以看到

   skb = skb_peek_tail(queue);

exthdrlen = !skb ? rt->dst.header_len : 0;
mtu = cork->fragsize;
if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
    sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
	tskey = sk->sk_tskey++;

计算 L2 头部长度，fragment 头部长度，最大可以容纳的 fragment 长度，还有不分片的情况下的最大长度。（如果忽略分片就直接默认最大值，64KB 就是 0xFFFF，否则使用 mtu）

hh_len = LL_RESERVED_SPACE(rt->dst.dev);

fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
maxnonfragsize = ip_sk_ignore_df(sk) ? 0xFFFF : mtu;

首先累加的 buffer 长度不能超过最大的 IP 包长度。

if (cork->length + length > maxnonfragsize - fragheaderlen) {
	ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
		       mtu - (opt ? opt->optlen : 0));
	return -EMSGSIZE;
}

如果是第一个包，并且不会有新的分片，并且硬件支持 checksum 就可以标志为 CHECKSUM_PARTIAL。

/*
 * transhdrlen > 0 means that this is the first fragment and we wish
 * it won't be fragmented in the future.
 */
if (transhdrlen &&
    length + fragheaderlen <= mtu &&
    rt->dst.dev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM) &&
    !(flags & MSG_MORE) &&
    !exthdrlen)
	csummode = CHECKSUM_PARTIAL;

下面如果满足下面条件就进入 UDP Fragment Offload 例程。是硬件网卡提供的一种特性，由内核和驱动配合完成相关功能。其目的是由网卡硬件来完成本来需要软件进行的分段（分片）操作用于提升效率和性能。如大家所知，在网络上传输的数据包不能大于 mtu，当用户发送大于 mtu 的数据报文时，通常会在传输层（或者在特殊情况下在 IP 层分片，比如 ip 转发或 ipsec 时）就会按 mtu 大小进行分段，防止发送出去的报文大于 mtu，为提升该操作的性能，新的网卡硬件基本都实现了 UFO 功能，可以使分段（或分片）操作在网卡硬件完成，此时用户态就可以发送长度大于 mtu 的包，而且不必在协议栈中进行分段（或分片）。如果硬件支持，是 UDP 协议，并且是大于 mtu 的可以直接用这个函数。

if ((((length + fragheaderlen) > mtu) || (skb && skb_is_gso(skb))) &&
    (sk->sk_protocol == IPPROTO_UDP) &&
    (rt->dst.dev->features & NETIF_F_UFO) && !dst_xfrm(&rt->dst) &&
    (sk->sk_type == SOCK_DGRAM) && !sk->sk_no_check_tx) {
	err = ip_ufo_append_data(sk, queue, getfrag, from, length,
				 hh_len, fragheaderlen, transhdrlen,
				 maxfraglen, flags);
	if (err)
		goto error;
	return 0;
}

剩下的代码有点啰嗦，总体来说就是把 buff 拆分成可以直接发送的 IP fragment，但是需要先把道理讲清楚，不然看代码有点复杂。

确定剩余可以用来拷贝的空间，不能超过 mtu 和 maxfraglen

/* Check if the remaining data fits into current packet. */
	copy = mtu - skb->len;
	if (copy < length)
		copy = maxfraglen - skb->len;

如果不够，就需要分配一个新的 skb，这里面的几个变量具体解释一下，首先是

fraggap 表示的是 mtu 不是 8 的倍数，在最后那个比 8 的倍数多，又小于 mtu 的部分就是 fraggap 了，所以 datalen 是 length + fraggap，fraggap 这部分会从 prev_skb 尾部移动到新 skb 的头部。fraglen 是带上 frag 头部的长度 fraglen = datalen + fragheaderlen。如果 flag 包含了 MSG_MORE 那么会尽量分配一个 mtu，当然这是在不支持 SG(Scatter/Gather I/O) 的情况下。因为支持 SG 的话，就可以直接分散的分配这些内存，最后进行 skb 的分配。

		if (copy <= 0) {
			char *data;
			unsigned int datalen;
			unsigned int fraglen;
			unsigned int fraggap;
			unsigned int alloclen;
			struct sk_buff *skb_prev;
alloc_new_skb:
			skb_prev = skb;
			if (skb_prev)
				fraggap = skb_prev->len - maxfraglen;
			else
				fraggap = 0;

			/*
			 * If remaining data exceeds the mtu,
			 * we know we need more fragment(s).
			 */
			datalen = length + fraggap;
			if (datalen > mtu - fragheaderlen)
				datalen = maxfraglen - fragheaderlen;
			fraglen = datalen + fragheaderlen;

			if ((flags & MSG_MORE) &&
			    !(rt->dst.dev->features&NETIF_F_SG))
				alloclen = mtu;
			else
				alloclen = fraglen;

			alloclen += exthdrlen;

			/* The last fragment gets additional space at tail.
			 * Note, with MSG_MORE we overallocate on fragments,
			 * because we have no idea what fragment will be
			 * the last.
			 */
			if (datalen == length + fraggap)
				alloclen += rt->dst.trailer_len;

			if (transhdrlen) {
				skb = sock_alloc_send_skb(sk,
						alloclen + hh_len + 15,
						(flags & MSG_DONTWAIT), &err);
			} else {
				skb = NULL;
				if (atomic_read(&sk->sk_wmem_alloc) <=
				    2 * sk->sk_sndbuf)
					skb = sock_wmalloc(sk,
							   alloclen + hh_len + 15, 1,
							   sk->sk_allocation);
				if (unlikely(!skb))
					err = -ENOBUFS;
			}
			if (!skb)
				goto error;

length 表示需要传输的长度，在循环不断进行中这个 length 就会变成 0。

接下来的部分是初始化 csum 和 ip_summed 保留硬件头部长度。

         /*
 *	Fill in the control structures
 */
skb->ip_summed = csummode;
skb->csum = 0;
skb_reserve(skb, hh_len);

设置 tx_flags 和 tskey

/* only the initial fragment is time stamped */
			skb_shinfo(skb)->tx_flags = cork->tx_flags;
			cork->tx_flags = 0;
			skb_shinfo(skb)->tskey = tskey;
			tskey = 0;

保留数据空间，并且把指针移动到头部后面，指向负载的部分。

 *	Find where to start putting bytes.
 */
data = skb_put(skb, fraglen + exthdrlen);
skb_set_network_header(skb, exthdrlen);
skb->transport_header = (skb->network_header +
			 fragheaderlen);
data += fragheaderlen + exthdrlen;

这部分就是把上个 skb 的 fraggap 移到当前这个，并且重新获取 checksum。

if (fraggap) {
	skb->csum = skb_copy_and_csum_bits(
		skb_prev, maxfraglen,
		data + transhdrlen, fraggap, 0);
	skb_prev->csum = csum_sub(skb_prev->csum,
				  skb->csum);
	data += fraggap;
	pskb_trim_unique(skb_prev, maxfraglen);
}

接下来调用 getfrag 拷贝数据，加入到队尾。

getfrag 对应的 4 个 routine 分别是

• ICMP icmp_glue_bits
• UDP. ip_generic_getfrag
• RAW iP ip_generic_getfrag
• TCP. Ip_reply_glue_bits

getfrag 的功能就是从 from 拷贝到 to ，因为可能是用户态的数据，所以包含了地址转换的功能并且在比好的时候重新计算校验和。

	copy = datalen - transhdrlen - fraggap;
	if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
		err = -EFAULT;
		kfree_skb(skb);
		goto error;
	}

	offset += copy;
	length -= datalen - fraggap;
	transhdrlen = 0;
	exthdrlen = 0;
	csummode = CHECKSUM_NONE;

	if ((flags & MSG_CONFIRM) && !skb_prev)
		skb_set_dst_pending_confirm(skb, 1);

	/*
	 * Put the packet on the pending queue.
	 */
	__skb_queue_tail(queue, skb);
	continue;
}

剩下的就是 copy 足够，不需要分配新的 skb 的条件。

if (copy > length)
	copy = length;

if (!(rt->dst.dev->features&NETIF_F_SG)) {
	unsigned int off;

	off = skb->len;
	if (getfrag(from, skb_put(skb, copy),
			offset, copy, off, skb) < 0) {
		__skb_trim(skb, off);
		err = -EFAULT;
		goto error;
	}
} else {
	int i = skb_shinfo(skb)->nr_frags;

	err = -ENOMEM;
	if (!sk_page_frag_refill(sk, pfrag))
		goto error;

	if (!skb_can_coalesce(skb, i, pfrag->page,
			      pfrag->offset)) {
		err = -EMSGSIZE;
		if (i == MAX_SKB_FRAGS)
			goto error;

		__skb_fill_page_desc(skb, i, pfrag->page,
				     pfrag->offset, 0);
		skb_shinfo(skb)->nr_frags = ++i;
		get_page(pfrag->page);
	}
	copy = min_t(int, copy, pfrag->size - pfrag->offset);
	if (getfrag(from,
		    page_address(pfrag->page) + pfrag->offset,
		    offset, copy, skb->len, skb) < 0)
		goto error_efault;

	pfrag->offset += copy;
	skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
	skb->len += copy;
	skb->data_len += copy;
	skb->truesize += copy;
	atomic_add(copy, &sk->sk_wmem_alloc);
}
offset += copy;
length -= copy;