linux内核 ip分片,linux内核ip分片函数ip_fragment解析

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, pad;

int offset;

__be16 not_last_frag;

/* 取得路由表 */

struct rtable *rt = skb->rtable;

int err = 0;

/* 网络设备 */

dev = rt->u.dst.dev;

/*

*Point into the IP datagram header.

*/

/* 取得ip头 */

iph = ip_hdr(skb);

/*

* 判断DF位，知道如果df位被设置了话就表示不要被分片，

* 这时ip_fragment将会发送一个icmp报文返回到源主机。这里

* 主要是为forward数据所判断。

*/

if (unlikely((iph->frag_off & htons(IP_DF)) && !skb->local_df)) {

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);

icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,

htonl(ip_skb_dst_mtu(skb)));

kfree_skb(skb);

return -EMSGSIZE;

}

/*

*Setup starting values.

*/

/* 得到ip头的长度 */

hlen = iph->ihl * 4;

/*

* 得到mtu的大小。这里要注意，他的大小减去了hlen，也就是ip头的大小

*/

mtu = dst_mtu(&rt->u.dst) - hlen;/* Size of data space */

IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;

/* When frag_list is given, use it. First, check its validity:

* some transformers could create wrong frag_list or break existing

* one, it is not prohibited. In this case fall back to copying.

*

* LATER: this step can be merged to real generation of fragments,

* we can switch to copy when see the first bad fragment.

*/

/*

* 如果4层将数据包分片了，那么就会把这些数据包放到skb的frag_list链表中，

* 因此这里首先先判断frag_list链表是否为空，为空的话将会进行slow 分片

*/

if (skb_shinfo(skb)->frag_list) {

struct sk_buff *frag;

/*

* 取得第一个数据报的len.当sk_write_queue队列被flush后，

* 除了第一个切好包的另外的包都会加入到frag_list中，而这里

* 需要得到的第一个包(也就是本身这个sk_buff)的长度。

*/

int first_len = skb_pagelen(skb);

int truesizes = 0;

/*

* 接下来的判断都是为了确定能进行fast分片。分片不能被共享，

* 这是因为在fast path 中，需要加给每个分片不同的ip头(而并

* 不会复制每个分片)。因此在fast path中是不可接受的。而在

* slow path中，就算有共享也无所谓，因为他会复制每一个分片，

* 使用一个新的buff。

*/

/*

* 判断第一个包长度是否符合一些限制(包括mtu，mf位等一些限制).

* 如果第一个数据报的len没有包含mtu的大小这里之所以要把第一个

* 切好片的数据包单独拿出来检测，是因为一些域是第一个包所独有

* 的(比如IP_MF要为1)。这里由于这个mtu是不包括hlen的mtu，因此

* 需要减去一个hlen。

*/

if (first_len - hlen > mtu ||

((first_len - hlen) & 7) ||

(iph->frag_off & htons(IP_MF|IP_OFFSET)) ||

skb_cloned(skb))

goto slow_path;

/* 遍历剩余的frag */

for (frag = skb_shinfo(skb)->frag_list; frag; frag = frag->next) {

/* Correct geometry. */

/*

* 判断每个帧的mtu，以及相关的东西，如果不符合条件则要

* 进行slow path,基本和上面的第一个skb的判断类似

*/

if (frag->len > mtu ||

((frag->len & 7) && frag->next) ||

skb_headroom(frag) < hlen)

goto slow_path;

/* Partially cloned skb? */

/* 判断是否共享 */

if (skb_shared(frag))

goto slow_path;

BUG_ON(frag->sk);

/* 进行socket的一些操作 */

if (skb->sk) {

sock_hold(skb->sk);

frag->sk = skb->sk;

frag->destructor = sock_wfree;

truesizes += frag->truesize;

}

}

/* Everything is OK. Generate! */

/* 通过上面的检测，都通过了，因此可以进行fast path分片了 */

err = 0;

offset = 0;

/* 取得frag_list列表 */

frag = skb_shinfo(skb)->frag_list;

skb_shinfo(skb)->frag_list = NULL;

/* 得到数据(不包括头)的大小 */

skb->data_len = first_len - skb_headlen(skb);

skb->truesize -= truesizes;

skb->len = first_len;

iph->tot_len = htons(first_len);

/* 设置mf位 */

iph->frag_off = htons(IP_MF);

ip_send_check(iph);

/* 开始进行发送 */

for (;;) {

/* Prepare header of the next frame,

* before previous one went down. */

if (frag) {

frag->ip_summed = CHECKSUM_NONE;

/* 设置相应的头部 */

skb_reset_transport_header(frag);

/* 预留ddos header 空间 */

// hlen += DDOS_HDR_LEN;

__skb_push(frag, hlen);

skb_reset_network_header(frag);

// hlen -= DDOS_HDR_LEN;

/* 复制ip头 */

memcpy(skb_network_header(frag), iph, hlen);

iph = ip_hdr(frag);

iph->tot_len = htons(frag->len);

/* 将当前skb的一些属性付给将要传递的分片好的帧 */

ip_copy_metadata(frag, skb);

/* 处理ip_option */

if (offset == 0)

ip_options_fragment(frag);

offset += skb->len - hlen;

/* 设置位移 */

iph->frag_off = htons(offset>>3);

if (frag->next != NULL)

iph->frag_off |= htons(IP_MF);

/* Ready, complete checksum */

ip_send_check(iph);

}

/* 调用输出函数 */

err = output(skb);

if (!err)

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);

if (err || !frag)

break;

/* 处理链表中下一个buf */

skb = frag;

frag = skb->next;

skb->next = NULL;

}

if (err == 0) {

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);

return 0;

}

/* 释放内存 */

while (frag) {

skb = frag->next;

kfree_skb(frag);

frag = skb;

}

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);

return err;

}

slow_path:

/* 分片的数据剩余长度 */

left = skb->len - hlen;/* Space per frame */

/* 而ptr就是分片开始的数据指针 */

ptr = raw + hlen;/* Where to start from */

/* for bridged IP traffic encapsulated inside f.e. a vlan header,

* we need to make room for the encapsulating header

*/

/* 处理桥接、VLAN、PPPOE相关MTU */

pad = nf_bridge_pad(skb);

ll_rs = LL_RESERVED_SPACE_EXTRA(rt->u.dst.dev, pad);

mtu -= pad;

/*

*Fragment the datagram.

*/

/* 取出ip offset域 */

offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;

/* not_last_frag表明这个帧是否是最后一个分片 */

not_last_frag = iph->frag_off & htons(IP_MF);

/*

*Keep copying data until we run out.

*/

/* 开始为循环处理，每一个分片创建一个skb buffer */

while (left > 0) {

len = left;

/* IF: it doesn't fit, use 'mtu' - the data space left */

/* 如果len大于mtu，设置当前的将要分片的数据大小为mtu */

if (len > mtu)

len = mtu;

/* IF: we are not sending upto and including the packet end

then align the next start on an eight byte boundary */

/* 长度对齐 */

if (len < left){

len &= ~7;

}

/*

*Allocate buffer.

*/

/* malloc一个新的buff,它的大小包括ip payload,ip head,以及L2 head */

if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {

NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!/n");

err = -ENOMEM;

goto fail;

}

/*

*Set up data on packet

*/

/* 调用ip_copy_metadata复制一些相同的值的域 */

ip_copy_metadata(skb2, skb);

/* 保留L2 header空间 */

skb_reserve(skb2, ll_rs);

/* 设置ip header & ddos header & ip paylod 空间 */

skb_put(skb2, len + hlen);

skb_reset_network_header(skb2);

/* L4 header指针为ip header + ddos header数据偏移位置,用于复制原始payload */

skb2->transport_header = skb2->network_header + hlen;

/*

*Charge the memory for the fragment to any owner

*it might possess

*/

/* 将每一个分片的ip包都关联到源包的socket */

if (skb->sk)

skb_set_owner_w(skb2, skb->sk);

/*

*Copy the packet header into the new buffer.

*/

/* 拷贝ip header */

skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen);

/*

*Copy a block of the IP datagram.

*/

/* 拷贝ip payload数据 */

if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len))

BUG();

/* 分片的数据剩余长度 */

left -= len;

/*

*Fill in the new header fields.

*/

/* 填充相应的ip头 */

iph = ip_hdr(skb2);

iph->frag_off = htons((offset >> 3));

/* ANK: dirty, but effective trick. Upgrade options only if

* the segment to be fragmented was THE FIRST (otherwise,

* options are already fixed) and make it ONCE

* on the initial skb, so that all the following fragments

* will inherit fixed options.

*/

/* 第一个包，因此进行ip_option处理 */

if (offset == 0)

ip_options_fragment(skb);

/*

*Added AC : If we are fragmenting a fragment that's not the

* last fragment then keep MF on each bit

*/

/* 不是最后一个包，因此设置mf位 */

if (left > 0 || not_last_frag)

iph->frag_off |= htons(IP_MF);

/* 移动数据指针以及更改数据偏移 */

ptr += len;

offset += len;

/*

*Put this fragment into the sending queue.

*/

/* 增加ddos header 长度 */

// hlen += DDOS_HDR_LEN;

/* 更新包头的数据长度 */

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

/* 重新计算校验 */

ip_send_check(iph);

/* 复位ip header大小 */

// hlen -= DDOS_HDR_LEN;

err = output(skb2);

if (err)

goto fail;

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);

}

kfree_skb(skb);

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);

return err;

fail:

kfree_skb(skb);

IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);

return err;

}