本文以 linux 2.6.27.62 中 UDP 发包过程中重要的一个 IP 层的函数来分析 IP 层是如何分片的。

        科普一下，什么是 IP 包分片，在某一个链路上，比如在以太网链路上，每次所能发送最大的包是有限制的，叫做 MTU，也就是 IP 层要想发包，每次包大小必须不大于 MTU，见上一篇文章，但传输层很有可能发送大于这个值的数据，此时  IP 层会对这些数据（可以称为 IP 包）进行分片，然后在收到时，在 IP 层再进行重组，形成一个 IP 包，交给传输层。

        代码如下：

int ip_append_data(struct sock *sk,
		   int getfrag(void *from, char *to, int offset, int len,
			       int odd, struct sk_buff *skb),
		   void *from, int length, int transhdrlen,
		   struct ipcm_cookie *ipc, struct rtable *rt,
		   unsigned int flags)
{
	struct inet_sock *inet = inet_sk(sk);
	struct sk_buff *skb;

	struct ip_options *opt = NULL;
	int hh_len;
	int exthdrlen;
	int mtu;
	int copy;
	int err;
	int offset = 0;
	unsigned int maxfraglen, fragheaderlen;
	int csummode = CHECKSUM_NONE;

	// 如果只是为了探测，则不发包，直接返回
	if (flags&MSG_PROBE)
		return 0;

	// 检查发送队列是否为空，如果为空，则表示这是 IP 包的第一个分片
	if (skb_queue_empty(&sk->sk_write_queue)) {
		/*
		 * setup for corking.
		 */
		opt = ipc->opt;
		if (opt) {
			if (inet->cork.opt == NULL) {
				inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation);
				if (unlikely(inet->cork.opt == NULL))
					return -ENOBUFS;
			}
			memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen);
			inet->cork.flags |= IPCORK_OPT;
			inet->cork.addr = ipc->addr;
		}
		dst_hold(&rt->u.dst);
		inet->cork.fragsize = mtu = inet->pmtudisc == IP_PMTUDISC_PROBE ?
					    rt->u.dst.dev->mtu :
					    dst_mtu(rt->u.dst.path);
		inet->cork.dst = &rt->u.dst;
		inet->cork.length = 0;
		sk->sk_sndmsg_page = NULL;
		sk->sk_sndmsg_off = 0;
		if ((exthdrlen = rt->u.dst.header_len) != 0) {
			length += exthdrlen;
			transhdrlen += exthdrlen;
		}
	} else {
		rt = (struct rtable *)inet->cork.dst;
		if (inet->cork.flags & IPCORK_OPT)
			opt = inet->cork.opt;

		transhdrlen = 0;		// 如果该 IP 包里还有分片，那么就会忽略掉此次的传输层头信息，直接添加到上一个 IP 包
		exthdrlen = 0;
		mtu = inet->cork.fragsize;
	}

	// 计算 L2 层头部长度，即链路层，以太网为 1500
	hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);

	// 计算该层，即 IP 层头部长度
	fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
	// 计算该分片，如果不是最后一片，那么它的载荷最大为多少，8 字节对齐的原因，见上一篇《IP层分析》一文
	// maxfraglen 表示如果不是最后一个分片的分片的最大长度
	maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;

	// 该 IP 包的载荷是否超过了最大限制，总大小为什么是 0xFFFF，见上一文
	if (inet->cork.length + length > 0xFFFF - fragheaderlen) {
		ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen);
		return -EMSGSIZE;
	}

	/*
	 * 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->u.dst.dev->features & NETIF_F_V4_CSUM &&
	    !exthdrlen)
		csummode = CHECKSUM_PARTIAL;             // 让硬件，即网卡计算校验和

	// 更新该 IP 包已累积的数据的长度，cork 相当于软木塞，使小的数据包可以积累成为一个大的 IP 包
	inet->cork.length += length;
	if (((length> mtu) || !skb_queue_empty(&sk->sk_write_queue)) &&
	    (sk->sk_protocol == IPPROTO_UDP) &&
	    (rt->u.dst.dev->features & NETIF_F_UFO)) {
		err = ip_ufo_append_data(sk, getfrag, from, length, hh_len,
					 fragheaderlen, transhdrlen, mtu,
					 flags);
		if (err)
			goto error;
		return 0;
	}

	/* So, what's going on in the loop below?
	 *
	 * We use calculated fragment length to generate chained skb,
	 * each of segments is IP fragment ready for sending to network after
	 * adding appropriate IP header.
	 */
	// 取出该 IP 包的最后一个 sk_buff，即最后一个分片
	if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
		goto alloc_new_skb;

	// 下面开始 IP 分片的主逻辑
	while (length > 0) {
		/* Check if the remaining data fits into current packet. */
		// 检查最后一个分片的剩余空间是否可以满足当前的包，最后一个分片的大小因为不需要满足 8 字节对齐
		// 所以它的大小有可能，大于 maxfraglen，但肯定小于 mtu. 所以如果 copy 如果可以满足 length，那么
		// 就不用申请新的分片，直接填充到最后一个分片中。但如果 copy 不能满足 length （copy < length）, 
		// 那么就需要新和分片，此时上次的最后一个分片的大小就需要做 8 字节对齐处理。所以 copy 记录了能够从
		// length 中拷贝的数据的大小
		copy = mtu - skb->len;
		if (copy < length)
			copy = maxfraglen - skb->len;

		// 如果最后一个分片不能满足此次请求，并且 skb->len >= maxfraglen时，此时 copy <= 0, 也就是最后一个
		// 分片有可能需要作处理，移动最后没有 8 字节对齐的部分
		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:
			// 取出上一个分片，因为上一个分片在处理时有可能被当作最后一个分片处理，长度可能不是 8 的倍数，此处要处理这种情况
			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->u.dst.dev->features&NETIF_F_SG))
				alloclen = mtu;
			else
				alloclen = datalen + fragheaderlen;

			/* 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->u.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 == NULL))
					err = -ENOBUFS;
			}
			if (skb == NULL)
				goto error;

			/*
			 *	Fill in the control structures
			 */
			skb->ip_summed = csummode;
			skb->csum = 0;
			// 保留 L2 层，即链路层长度，该保留动作不会影响 skb->len， skb->len 只记录了 IP 层数据的长度，包括 IP 头信息
			skb_reserve(skb, hh_len);

			/*
			 *	Find where to start putting bytes.
			 */
			data = http://www.mamicode.com/skb_put(skb, fraglen);>
        通过代码分析，我们不难发现，在使用 UDP 传输时，由于有 cork 操作的存在（该操作可由用户控制），当频繁发送小数据时，会累积成一个 IP 包，当发送大数据时，如果不超过 IP 层所能接受的最大长度，则 IP 层会对它进行分片，并且很有可能与上一个 IP 包粘连。
        Remark: IP 层的一些特性，为什么中间分片需要 8 字节对齐，可参见上一篇中 <<IP层分析>>，最后一个分片是不需要 8 字节对齐的，在代码中为了处理这些情况，有非常多的逻辑。还有，此次请求的最后一个分片，很有可能在下次请求时，为了利用上一次的 IP 包，从而使得本来的最后分片，成为了中间分片，进而必须处理掉分片中的字节对齐的情况。 sk_buff 是个重要的结构，它是用来描述 IP 包中的 IP 分片的信息的。因为对 IP 层来讲，它只关心自己的头信息和载荷，但一般能组成一个 UDP 包的载荷其实只需要一个 UDP 头，所以一般只有第一个分片中带有 UDP 头，其它分片中不用传输层的头了，也就相当于把多个传输层的包合并了。


这也相当于在网络层去关心传输层的一个特例了吧。
IP 包分片