网络子系统51_ip协议报文分片

//ip分片
//	快速路径的条件：
//		1.skb
//			1.skb的数据长度(主缓存区+frags缓存区)小于输出路径的mtu
//			2.skb的数据长度对齐到8字节的边界
//			3.skb没有被分片
//			4.skb没有被共享
//		2.skb->frag_list
//			1.长度小于(mtu-ip报头-选项)
//			2.除最后一个分片外，长度都需要对齐到8字节边界
//			3.head-data之间的空间，可以容纳ip报头
//	注：skb->frag_list的skb，没有填充ip头，skb填充有ip头
//
//	慢速路径条件：
//		只要不满足快速路径其中的一条，使用慢速路径

//	快速路径处理过程：
//		1.第一个分片使用完整的ip选项
//		2.其余分片使用部分ip选项
//		3.除最后一个分片外，设置MF标志
//		4.设置offset
//		5.使用相同的路由信息，向下层传递

//	慢速路径处理过程：
//		1.分配新的skb，长度为mtu，或者剩余数据量，对齐到8字节边界
//		2.预留l2帧头空间
//		3.拷贝l3报头，以及数据到新skb中
//		4.除第一个分片使用完整的ip选项，其余分片使用部分ip选项
//		5.设置offset
//		5.使用相同的路由信息，向下层传递


//	对比快速路径与慢速路径：
//		1.慢速路径的慢主要表现在分配新的缓存区，从旧缓存区中拷贝数据

//	注：ip报头的offset字段，只针对有效载荷(ip头，ip选项不包括在内)

//调用路径ip_output/ip_mc_output->ip_fragment
1.1 int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff*))
{
	struct iphdr *iph;
	int raw = 0;
	int ptr;
	struct net_device *dev;
	struct sk_buff *skb2;
	unsigned int mtu, hlen, left, len, ll_rs;
	int offset;
	int not_last_frag;
	struct rtable *rt = (struct rtable*)skb->dst;
	int err = 0;
	//出口设备
	dev = rt->u.dst.dev;
	//ip头
	iph = skb->nh.iph;
	//ip报头设置有DF标志，禁止分片
	////skb->local_df如果被设置，则在需要分片，但是设置DF标志，不向发送方传送ICMP消息
	if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {
		icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,//需要分片，但是设置DF标志，通知发送方不可达，原因是需要分片，并告知对方mtu
			  htonl(dst_pmtu(&rt->u.dst)));
		kfree_skb(skb);
		return -EMSGSIZE;
	}

	//可以快速分片的条件：
	//	skb
	//		1.skb的数据长度(主缓存区+frags缓存区)小于输出路径的mtu
	//		2.skb的数据长度对齐到8字节的边界
	//		3.skb没有被分片
	//		4.skb没有被共享
	//	skb->frag_list
	//		1.长度小于(mtu-ip报头)
	//		2.除最后一个分片外，长度都需要对齐到8字节边界
	//		3.head-data之间的空间，可以容纳ip报头
	//	注：skb->frag_list的skb，没有填充ip头，skb填充有ip头
	hlen = iph->ihl * 4;//ip头长度
	mtu = dst_pmtu(&rt->u.dst) - hlen;	//数据空间的大小

	if (skb_shinfo(skb)->frag_list) {//frag_list存在skb
		struct sk_buff *frag;
		int first_len = skb_pagelen(skb);//skb主缓存区，frags片段中的数据长度，不包括frag_list中的skb

		if (first_len - hlen > mtu ||//超过允许的最大数据量
		    ((first_len - hlen) & 7) ||//数据长度没有对齐到8字节
		    (iph->frag_off & htons(IP_MF|IP_OFFSET)) ||//此skb是一个分片
		    skb_cloned(skb))//克隆一份skb，慢速分片
			goto slow_path;
		//检查frag_list中的skb是否可以快速分片
		for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {
			//frag_list中的skb没有ip头
			if (frag->len > mtu ||
			    ((frag->len & 7) && frag->next) ||//除最后一个分片外，其他分片的长度必须对其到8字节
			    skb_headroom(frag) < hlen)//头空间不够容纳ip报头(ip头+选项)
			    goto slow_path;

			if (skb_shared(frag))//skb被共享
				goto slow_path;
		}
	//快速路径：
		err = 0;
		offset = 0;
		frag = skb_shinfo(skb)->frag_list;
		skb_shinfo(skb)->frag_list = NULL;
		//更新skb->data_len为skb->frags中数据的大小，原始skb->data_len包括frags，frag_list中所有数据的长度
		skb->data_len = first_len - skb_headlen(skb);
		skb->len = first_len;//更新总长度为主缓存区，frags中数据的大小，原始skb->len包括主缓存区，frags，frag_list中所有数据的长度
		iph->tot_len = htons(first_len);//ip报头的数据包长度
		iph->frag_off |= htons(IP_MF);//表示有更多的分片，第一个分片，offset=0
		ip_send_check(iph);//计算ip校验和

		for (;;) {
			if (frag) {//处理skb->frag_list中的skb，为其准备分片的ip报头
				frag->ip_summed = CHECKSUM_NONE;//表示校验和没有计算
				frag->h.raw = frag->data;
				frag->nh.raw = __skb_push(frag, hlen);//移动skb->data指针，填充ip报头和选项
				memcpy(frag->nh.raw, iph, hlen);
				iph = frag->nh.iph;
				iph->tot_len = htons(frag->len);//总长度
				ip_copy_metadata(frag, skb);//使分片skb与头skb有一样的出口设备，路由信息
				if (offset == 0)//第一个分片具有完整的选项，其他分片将所有非copied的选项，均设置为NOOP
					ip_options_fragment(frag);
				offset += skb->len - hlen;//计算本分片的偏移量
				iph->frag_off = htons(offset>>3);//偏移量对齐在8字节
				if (frag->next != NULL)
					iph->frag_off |= htons(IP_MF);//设置还有更多skb
				ip_send_check(iph);//计算ip校验和
			}

			err = output(skb);//向下传递前一个skb，调用ip_finish_output

			if (err || !frag)
				break;

			skb = frag;//保留指向前一个skb的指针
			frag = skb->next;//frag为下一个待处理的skb
			skb->next = NULL;//
		}

		if (err == 0) {
			IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
			return 0;
		}
		//快速路径分片出现错误，释放所有skb
		while (frag) {
			skb = frag->next;
			kfree_skb(frag);
			frag = skb;
		}
		IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
		return err;
	}

	//慢速路径
slow_path:
	left = skb->len - hlen;	//(主缓存区，frags，frag_list)数据的总大小(不包括ip头，选项)	
	ptr = raw + hlen;		//新分片的数据在原skb中的起始位置

	offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;//当前分片的偏移量
	not_last_frag = iph->frag_off & htons(IP_MF);//判断是否为最后一个分片

	//开始进行分片
	while(left > 0)	{
		len = left;
		if (len > mtu)//使用mtu(此处的mtu去掉ip报头和选项长度)
			len = mtu;
		
		if (len < left)	{
			len &= ~7;//长度对齐到8字节边界
		}
		//分配新的skb，长度包括l2帧头，l3报头，l3有效载荷
		if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {
			NETDEBUG(printk(KERN_INFO "IP: frag: no memory for new fragment!\n"));
			err = -ENOMEM;
			goto fail;
		}
		//使所有分片都使用相同的路由信息，出口设备
		ip_copy_metadata(skb2, skb);
		skb_reserve(skb2, ll_rs);//预留l2帧头
		skb_put(skb2, len + hlen);//data-tail之间空间大小为(ip报头+ip选项+ip有效载荷)
		skb2->nh.raw = skb2->data;//设置l3报头起始地址
		skb2->h.raw = skb2->data + hlen;//l3有效载荷
		//设置新创建的skb所属的sock
		if (skb->sk)
			skb_set_owner_w(skb2, skb->sk);
		//拷贝ip头，选项
		memcpy(skb2->nh.raw, skb->data, hlen);
		//将skb起始地址为ptr的len个字节拷贝到skb2中
		//由skb_copy_bits处理frag，frag_list
		if (skb_copy_bits(skb, ptr, skb2->h.raw, len))
			BUG();
		left -= len;//更新剩余待分片的数据量

		iph = skb2->nh.iph;
		iph->frag_off = htons((offset >> 3));//偏移量

		//1.只有第一个分片需要完整的选项，其他分片将非copied的选项设置为NOOP
		//2.由于第一个分片已经拷贝完整的ip报头以及选项到其分片中
		//3.优化效率，在第一个分片拷贝完整的选项后，更新选项，非第一个分片都使用相同的ip选项
		if (offset == 0)
			ip_options_fragment(skb);

		if (left > 0 || not_last_frag)
			iph->frag_off |= htons(IP_MF);//还有跟多的分片
		ptr += len;//下一个分片的数据在原skb中的起始位置
		offset += len;//偏移量

		IP_INC_STATS(IPSTATS_MIB_FRAGCREATES);

		iph->tot_len = htons(len + hlen);

		ip_send_check(iph);

		err = output(skb2);
		if (err)
			goto fail;
	}
	kfree_skb(skb);
	IP_INC_STATS(IPSTATS_MIB_FRAGOKS);
	return err;

fail:
	kfree_skb(skb); 
	IP_INC_STATS(IPSTATS_MIB_FRAGFAILS);
	return err;
}

//调用路径 ip_fragment->ip_options_fragment
//	修改ip_option(skb->cb)，将非copied类型的选项，均设置为NOOP类型
2.1 void ip_options_fragment(struct sk_buff * skb) 
{
	unsigned char * optptr = skb->nh.raw;
	struct ip_options * opt = &(IPCB(skb)->opt);
	int  l = opt->optlen;
	int  optlen;

	while (l > 0) {
		switch (*optptr) {
		case IPOPT_END:
			return;
		case IPOPT_NOOP:
			l--;
			optptr++;
			continue;
		}
		optlen = optptr[1];
		if (optlen<2 || optlen>l)
		  return;
		if (!IPOPT_COPIED(*optptr))//在选项type的第8个比特，指出该选项是否应该复制到ip分片中
			memset(optptr, IPOPT_NOOP, optlen);//对不需要拷贝到除第一个分片外的选项，设置为NOOP
		l -= optlen;
		optptr += optlen;
	}
	opt->ts = 0;//均设置为0，表明不需要time stamp，record route
	opt->rr = 0;
	opt->rr_needaddr = 0;
	opt->ts_needaddr = 0;
	opt->ts_needtime = 0;
	return;
}