linux TCP/IP协议栈 ---__pskb_pull_tail()

在ip_rcv()函数当中遇到了pskb_may_pull()这个函数，进行了简单的注释：

/* 

 *pskb_may_pull确保skb->data指向的内存包含的数据至少为IP头部大小，由于每个

 *IP数据包包括IP分片必须包含一个完整的IP头部。如果小于IP头部大小，则缺失

 *的部分将从数据分片中拷贝。这些分片保存在skb_shinfo(skb)->frags[]中。

 */

if (!pskb_may_pull(skb, sizeof(struct iphdr)))

当数据包进入协议栈往上层递交的过程中，比如在IP层，它需要对数据包的IP头部进行分析，比如头部合法性等，这时候就需要确保IP头部在线性缓冲区中，这样才能对它进行分析，如果在非线性缓冲区中，而非线性缓冲区是unmapped的page，因此就需要从这些unmapped page当中把数据复制到线性缓冲区中。
这个艰难的工作就是__pskb_pull_tail完成的。我将对它的代码进行单独的分析。

当然最好情况是skb->data指向的线性缓冲区中的数据至少是大于len的，这样就可以直接返回了成功了。
len一定是不能大于整个skb的数据总长的。这个就不必说明吧...
线性缓冲区中数据不足，不幸还是发生了...调用__pskb_pull_tail。

1. static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
2. {
3.     /* skb_headlen定义为skb->len - skb->data_len。即skb->head指向的线性缓冲区里当前
4.      * 有效数据的长度。*/
5.     if (likely(len <= skb_headlen(skb)))
6.         return 1;
7.     if (unlikely(len > skb->len))
8.         return 0;
9.     return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
10. }

额...这个函数还是相当复杂的。首先需要了解的就是收到的包的数据在sk_buff中是如何组织的。
数据先会出现在sk_buff->data中，也就是线性数据缓冲区，多余的数据就放在skb_shinfo(skb)->frag[]当中，这些数据存在于所谓的非线性缓冲区当中，这些数据都存在于unmapped page当中，这是用于支持驱动的分散/聚集 I/O的。另外，还有一部分存在于skb_shinfo(skb)->frag_list当中，这是一个sk_buff结构的链表。所以，对shk_shinfo(skb)->frag_list当中的sk_buff中的数据可以进行上述的递归表达。
数据的连续性和这里描述的数据缓冲区中的数据是一致的。
该函数的定义为

1. unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)

delta参数是skb->tail需要前进的字节数。而skb->tail是线性数据缓冲区的结尾，后面不含任何有效数据，
所以delta参数也是需要从其他部分拷贝数据到线性缓冲区的长度。

该函数比较长，下面分段描述。

1. /**
2.  *    __pskb_pull_tail - advance tail of skb header
3.  *    @skb: buffer to reallocate
4.  *    @delta: number of bytes to advance tail
5.  *
6.  *    The function makes a sense only on a fragmented &sk_buff,
7.  *    it expands header moving its tail forward and copying necessary
8.  *    data from fragmented part.
9.  *
10.  *    &sk_buff MUST have reference count of 1.
11.  *
12.  *    Returns %NULL (and &sk_buff does not change) if pull failed
13.  *    or value of new tail of skb in the case of success.
14.  *
15.  *    All the pointers pointing into skb header may change and must be
16.  *    reloaded after call to this function.
17.  */
18. 
    
19. /* Moves tail of skb head forward, copying data from fragmented part,
20.  * when it is necessary.
21.  * 1. It may fail due to malloc failure.
22.  * 2. It may change skb pointers.
23.  *
24.  * It is pretty complicated. Luckily, it is called only in exceptional cases.
25.  */

仔细看这个注释还是有必要的，如注释所说的，它极少情况下会被调用，因此看不下去也没关系，可以继续分析其他的，只需要知道它是干什么的，不必知道它是具体怎么做的。

1. unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta)
2. {
3.     /* If skb has not enough free space at tail, get new one
4.      * plus 128 bytes for future expansions. If we have enough
5.      * room at tail, reallocate without expansion only if skb is cloned.
6.      */
7.     int i, k, eat = (skb->tail + delta) - skb->end;
8.     /* eat > 0 说明skb的线性缓冲区尾部没有足够空闲空间，或者如果skb是被克隆过的那
9.      * 么pskb_expand_head会重新分配一个线性数据缓冲区，该缓冲区大小在原缓冲区的
10.      * 基础上，将尾部扩大eat + 128字节，或者得到一份新的数据缓冲区拷贝，它保证该
11.      * skb是没有克隆过，且数据缓冲区是私有的，即skb->cloned = 0且
12.      * skb_shareinfo(skb)->dataref = 1. 
13.      * 首先分析eat > 0 的情况下要扩展线性缓冲区尾部的理由很直接，因为尾部空间不
14.      * 足以容纳将要从其他地方拷贝来的数据。
15.      * skb是被克隆的情况下，需要一个私有的数据缓冲区，这是因为skb被克隆时，数
16.      * 据缓冲区是被共享的，而接下来需要从其他地方拷贝数据到线性缓冲区，也就是对
17.      * 缓冲区进行了修改，因此，需要一份私有的数据缓冲区。*/
18.     if (eat > 0 || skb_cloned(skb)) {
19.         if (pskb_expand_head(skb, 0, eat > 0 ? eat + 128 : 0,
20.                  GFP_ATOMIC))
21.             return NULL;
22.     }

这时候skb的线性数据缓冲区的tailroom有足够的空间来容纳即将被拷贝进来的数据，接下来当然就是进行数据拷贝，这个数据拷贝可是一个艰难的过程，不只是一个memcpy就可以做到的。因为前面提到过，有些数据存在于unmapped page当中，还有一些存在于其他skb片段当中。

1.     /* 
2.      * 从skb的线性数据区以及可能从非线性数据区，甚至可能从skb的frag_list链中拷贝
3.      * 总长度为delta的数据到skb_tail_pointer(skb)。这个函数也比较复杂，它甚至还递归！
4.      * 单独分析。 
5.      */
6.     if (skb_copy_bits(skb, skb_headlen(skb), skb_tail_pointer(skb), delta))
7.         BUG();

自此之后，所需要的数据都拷贝到了skb的线性数据缓冲区，所拷贝的数据在其他地方也存在，接下来要清理重复的数据也就顺理成章了。可这并不是简单的事。

1. /* Optimization: no fragments, no reasons to preestimate
2.      * size of pulled pages. Superb.
3.      */
4.     if (!skb_shinfo(skb)->frag_list)
5.         goto pull_pages;

如果执行goto，这当然是最好的了，skb_shinfo(skb)->frag_list如果是NULL，则表明上面的skb_copy_bits最坏只是从skb_shinfo(skb)->frags[]当中拷贝了数据。
如果skb_shinfo(skb)->frag_list不是NULL，则有可能从中拷贝了数据，我们需要测试一下。

1. /* Estimate size of pulled pages. */
2.     /* 统计这次从非线性缓冲区中拷贝了多少数据 */
3.     eat = delta;
4.     for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5.         if (skb_shinfo(skb)->frags[i].size >= eat)
6.             goto pull_pages;
7.         eat -= skb_shinfo(skb)->frags[i].size;
8.     }

若eat > 0，则表明的确从frag_list中拷贝了数据，否则没有。没有当然最好了。

不幸总是要来临的，首先要找到那些frag_list中的sk_buff中存在重复数据，因为frag_list中的sk_buff的数据是线性顺序的，所以，只要找到第一个没有重复的sk_buff即可，前面的所有sk_buff节点都是重复数据，因此需要释放掉这些sk_buff。

1. /* If we need update frag list, we are in troubles.
2.      * Certainly, it possible to add an offset to skb data,
3.      * but taking into account that pulling is expected to
4.      * be very rare operation, it is worth to fight against
5.      * further bloating skb head and crucify ourselves here instead.
6.      * Pure masohism, indeed. 8)8)
7.      */
8.     /* 如果eat大于零...那么本次的拷贝还从skb的frag_list中进行了拷贝*/
9.     if (eat) {
10.         struct sk_buff *list = skb_shinfo(skb)->frag_list;
11.         struct sk_buff *clone = NULL;
12.     /* insp记录第一个未被拷贝的sk_buff结构，在释放skb时有用。 */
13.         struct sk_buff *insp = NULL;    
14. 
    
15.         do {
16.             BUG_ON(!list);
17. 
    
18.             if (list->len <= eat) {    /* 这个sk_buff中的所有数据都被拷贝了。 */
19.                 /* Eaten as whole. */
20.                 eat -= list->len;
21.                 list = list->next;
22.                 insp = list;
23.             } else {
24.                 /* Eaten partially. */
25.     /* 有其他部分和我们共享这个skb的数据，所以需要克隆一个sk_buff
26.      * 因为接下我们要修改sk_buff中的指针。 */
27.                 if (skb_shared(list)) {
28.                     /* We need to fork list. :-( */
29.                     clone = skb_clone(list, GFP_ATOMIC);
30.                     if (!clone)
31.                         return NULL;
32.                     insp = list->next;
33.                     list = clone;
34.                 } else {
35.                     /* This may be pulled without
36.                      * problems. */
37.                     insp = list;
38.                 }
39.     /* 将list->data向前移动eat个字节，因为这部分已经被拷贝走了.额...
40.      * pskb_pull 可能会继续调用__pskb_pull_tail。好混乱，因为前面在调用
41.      * pskb_copy_bits时会对frag_list中的skb递归调用__pskb_copy_bits，而
42.      * 这个skb线性缓冲区中的数据可能又不满足需要拷贝的长度，因此又
43.      * 要从非线性缓冲、frag_list中拷贝数据...*/
44.                 if (!pskb_pull(list, eat)) {
45.                     if (clone)
46.                         kfree_skb(clone);
47.                     return NULL;
48.                 }
49.                 break;    /* 之后的skb的内容没有被拷贝...所以break */
50.             }
51.         } while (eat);

找到了链表中的结束位置，接下来就可以对重复的数据进行清理，释放掉这些多余的东西。

1. /* Free pulled out fragments. */
2.     /* 开始释放已经被拷贝了所有数据缓冲区内容的的sk_buff */
3.         while ((list = skb_shinfo(skb)->frag_list) != insp) {
4.             skb_shinfo(skb)->frag_list = list->next;
5.             kfree_skb(list);
6.         }

上面这些被free掉的skb，其包含的数据全部是重复的，所以可以完全释放掉。但是insp指向的sk_buff可能包含部分重复的数据，这个也需要进行处理，请看上一个代码块中if-else中else语句里的处理过程。

更新skb_shinfo(skb)->frag_list链表头，如果有需要的话。

1. /* 如果eat刚好覆盖的是几个skb_buff数据的总和，那么clone = NULL */
2.     /* 
3.         /* And insert new clone at head. */
4.         if (clone) {
5.             clone->next = list;
6.             skb_shinfo(skb)->frag_list = clone;
7.         }
8.     }

繁杂的skb_shinfo(skb)->frag_list处理完之后，还要对skb_shinfo(skb)->frag[]进行消除重复数据的梳理。这个过程相对还是比较愉快的。代码比较直观。

1. pull_pages:    /* 处理被eat掉的非线性数据缓冲区 */
2.     eat = delta;
3.     k = 0;
4.     for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
5.         if (skb_shinfo(skb)->frags[i].size <= eat) {
6.             put_page(skb_shinfo(skb)->frags[i].page);    /* 可能会导致释放该页面 */
7.             eat -= skb_shinfo(skb)->frags[i].size;
8.         } else { /* 重新调整非线性缓冲区 */
9.             skb_shinfo(skb)->frags[k] = skb_shinfo(skb)->frags[i];
10.             if (eat) {    
11.                 skb_shinfo(skb)->frags[k].page_offset += eat;
12.                 skb_shinfo(skb)->frags[k].size -= eat;
13.                 eat = 0;
14.             }
15.             k++;
16.         }
17.     }

剩下的工作就是更新skb的一些字段了。

1. skb_shinfo(skb)->nr_frags = k;    /* 更新现在剩余的非线性缓冲区中页面个数 */
2. 
   
3.     skb->tail += delta;    /* 更新tail指针 */
4.     skb->data_len -= delta;    /* 减少非线性缓冲区的数据长度 */
5. 
   
6.     return skb_tail_pointer(skb);    /* 返回线性数据缓冲区中的tail 指针 */
7. }

skb->tail += delta才是本函数的最根本的目的！

copy->cleanup->update是本函数的基本流程。