linux下ip协议(V4)的实现(三)

这次我们来看数据包如何从4层传递到3层。 

先看下面的图，这张图表示了4层和3层之间(也就是4层传输给3层)的传输所需要调用的主要的函数: 


 

我们注意到3层最终会把帧用dst_output函数进行输出，而这个函数，我们上一次已经讲过了，他会调用skb->dst->output这个虚函数(他会对包进行3层的处理)，而最终会调用一个XX_finish_output的函数，从而将数据传递到neighboring子系统。 

这张我们主要聚焦于ip_push_pending_frames,ip_append_data,ip_append_page,ip_queue_xmit这几个函数。 

ip_queue_xmit： 

4层协议(主要指tcp 和 sctp)将数据包按照pmtu切片(如果需要)，然后3层的工作只需要给传递下来的切片加上ip头就可以了(也就是说调用这个函数的时候，其实4层已经切好片了)。因此这个函数的处理逻辑比较简单。 

ip_push_pending_frames和后面的2个函数： 

4层调用这几个函数不会考虑切片，4层调用ip_append_data时会存储请求，也就是会将数据包排队(其中每个都不大于pmtu)到一个输出队列.这样的话使3层的处理更加方便和高效。 

当4层需要flush输出队列到3层时，他需要显式的调用ip_push_pending_frames.其实也就是发送包到dst_output. 
ip_append_page只是ip_append_data的一个变体。 

我们还看到rawip和igmp都是直接调用dst_output,也就是直接和3层交互。 

在linux中，每一个bsd socket都被表示为一个socket的数据结构，而每一个protocol family都被表示为一个包含着sock的数据结构，这里我们来看PF_INET的结构： 

Java代码  

1. struct inet_sock {  
2.     /* sk and pinet6 has to be the first two members of inet_sock */  
3.     struct sock     sk;  
4. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)  
5.     struct ipv6_pinfo   *pinet6;  
6. #endif  
7.     /* Socket demultiplex comparisons on incoming packets. */  
8. ...................................................  
9.     struct {  
10. ..........................................  
11.     } cork;  
12. };  

可以看到每个inet_sock都包含一个sock也就是socket，它存储了每个协议簇的私有部分的数据。这样只要给定我们一个sock，我们都能通过inet_sk来得到inet_sock的指针。其实按照他们的内存分布，他们的地址是一样的。 

而cork域则在ip_append_data和ip_append_page中扮演的重要的角色，它存储被这两个函数所需要的正确切片的一些上下文信息。 

接下来来看ip_queue_xmit的实现,这个函数主要是被tcp和sctp所使用，第一个参数表示被传递的buffer的指针，第二个参数主要是被sctp来使用，就是是否切片被允许的标志： 

Java代码  

1. int ip_queue_xmit(struct sk_buff *skb, int ipfragok)  
2. {  
3. ///取出sock，inet_sock以及option  
4.     struct sock *sk = skb->sk;  
5.     struct inet_sock *inet = inet_sk(sk);  
6.     struct ip_options *opt = inet->opt;  
7.     struct rtable *rt;  
8.     struct iphdr *iph;  
9.   
10.     /* Skip all of this if the packet is already routed, 
11.      * f.e. by something like SCTP. 
12.      */  
13. ///得到相关路由信息，如果buffer已经标记了相应的路由信息，则跳过下面的构造路由表。  
14.     rt = skb->rtable;  
15.     if (rt != NULL)  
16.         goto packet_routed;  
17.   
18. ///下面检测在这个sock中，路由是否已经cache，如果有，则检测这个路由是否还可以使用。  
19.     rt = (struct rtable *)__sk_dst_check(sk, 0);  
20. ///cache不存在，查找新路由。  
21.     if (rt == NULL) {  
22.         __be32 daddr;  
23.   
24.         /* Use correct destination address if we have options. */  
25.         daddr = inet->daddr;  
26. ///检测source route option  
27.         if(opt && opt->srr)  
28.             daddr = opt->faddr;  
29.   
30.         {  
31.             struct flowi fl = { .oif = sk->sk_bound_dev_if,  
32.                         .nl_u = { .ip4_u =  
33.                               { .daddr = daddr,  
34.                             .saddr = inet->saddr,  
35.                             .tos = RT_CONN_FLAGS(sk) } },  
36.                         .proto = sk->sk_protocol,  
37.                         .uli_u = { .ports =  
38.                                { .sport = inet->sport,  
39.                              .dport = inet->dport } } };  
40.   
41.             /* If this fails, retransmit mechanism of transport layer will 
42.              * keep trying until route appears or the connection times 
43.              * itself out. 
44.              */  
45.             security_sk_classify_flow(sk, &fl);  
46. ///如果是 strict source route option,则会在这个函数中进行下一跳的精确匹配。  
47.             if (ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 0))  
48.                 goto no_route;  
49.         }  
50. ///主要是保存一些设备的features。  
51.         sk_setup_caps(sk, &rt->u.dst);  
52.     }  
53.   
54. ///clone一个skb->dst，也就是引用计数+1了。  
55.     skb->dst = dst_clone(&rt->u.dst);  
56.   
57. packet_routed:  
58. ///当有strictroute option的时候，检测下一跳，如果不等，则丢掉这个包。这里丢掉包不需要发送icmp，因为我们本身就是源，因此只需要返回错误代码给高层就行了。  
59.     if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)  
60.         goto no_route;  
61. ///开始build ip头。  
62.   
63.   
64. ///移动指针指向ip头。  
65.     skb_push(skb, sizeof(struct iphdr) + (opt ? opt->optlen : 0));  
66. ///保存这个指针到network_head  
67.     skb_reset_network_header(skb);  
68. ///取出ip头  
69.     iph = ip_hdr(skb);  
70. ///实例化ip头。  
71.     *((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));  
72.     if (ip_dont_fragment(sk, &rt->u.dst) && !ipfragok)  
73.         iph->frag_off = htons(IP_DF);  
74.     else  
75.         iph->frag_off = 0;  
76.     iph->ttl      = ip_select_ttl(inet, &rt->u.dst);  
77.     iph->protocol = sk->sk_protocol;  
78.     iph->saddr    = rt->rt_src;  
79.     iph->daddr    = rt->rt_dst;  
80.     /* Transport layer set skb->h.foo itself. */  
81.   
82.     if (opt && opt->optlen) {  
83.         iph->ihl += opt->optlen >> 2;  
84. ///设定ip头不进行切片。  
85.         ip_options_build(skb, opt, inet->daddr, rt, 0);  
86.     }  
87. ///设置ip包的id。  
88.     ip_select_ident_more(iph, &rt->u.dst, sk,  
89.                  (skb_shinfo(skb)->gso_segs ?: 1) - 1);  
90.   
91. ///用来流量控制。  
92.     skb->priority = sk->sk_priority;  
93.     skb->mark = sk->sk_mark;  
94.   
95. ///这个函数首先进行ip checksum，最终会通过netfilter的hook，从而由netfilter来决定包丢弃还是传递给dst_output.  
96.     return ip_local_out(skb);  
97.   
98. no_route:  
99.     IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);  
100.     kfree_skb(skb);  
101.     return -EHOSTUNREACH;  
102. }  

接下来来看ip_append_data函数,先来看它的参数的含义： 

sk: 这个传输包的socket 
getfrag: 这个函数用来复制从4层接收到的负荷到数据帧(3层)。 
from: 4层的data起始指针。 
length: 将要传输的数据的大小，包括4层的头和4层的负荷。 
transhdrlen: 四层头的大小 
ipc: 需要正确forward数据报的一些信息。 
rt: 路由信息 
flags:这个变量样子是MSG_XXX，他们包括下面几个定义： 

  MSG_MORE: 这个是应用程序用来告诉4层这儿将会有更多的小数据包的传输，然后将这个标记再传递给3层，3层就会提前划分一个mtu大小的数据包，来组合这些数据帧。 
  MSG_DONTWAIT: 当这个flag被设置，调用ip_append_data将不会阻塞。 
  MSG_PROBE :当这个标记被设置，说明用户不想要真正的传输什么东西，而是知识探测路径。例如测试一个pmtu。 

解释下ip+append_data的大体架构，在ip_queue_xmit中，也就是tcp协议使用的传输中，每次传递下来的数据包都要扔给dst_output来处理，而在ip_append_data中，它可以通过MSG_MORE来创建一个最接近mtu大小的数据块，然后将传递下来数据包(小于mtu)的，多个组成一个最接近mtu大小的数据包，然后传递给dst_output.而且他还有一个sk_write_queue队列，这个队列保存了数据传输的请求，也就是将要传递给dst_output的数据包(上面所说的最接近mtu大小的数据包)组成一个队列，从而当ip_push_pending_frams调用时，传递给dst_output. 


下面这张图解释了，一个不需要切片，并且包含一个ipsec头的ip包通过ip_append_data后的结果： 


 

这里要注意3层头的填充是通过ip_push_pending来进行填充的。而且一般的4层协议不会直接调用ip_push_pending_frams,而是调用它的包装函数，比如udp就会调用udp_push_pending_frames。 

还有一个要注意的是，当没有msg_more时，如果有一个大于pmtu的包传递下来时，他会切包，其中第一个包为pmtu大小，第二个包是剩下的大小，然后把这两个包加入到sk_write_queue队列。而设置了msg_more,此时第二个包的大小就是pmtu，也就是说当再有小的数据包下来，就不需要再次分配空间，而可以直接加入到剩余的数据空间中。 

有些硬件设备提供Scatter/Gather I/o这也就意味着能够交由硬件来组合这些小的数据包(3层可以什么都不用做，当数据包离开host的时候，硬件会将它组合好)，这样就降低了分配内存和复制数据的开销。 

由于一个sk buff只会有一个ip头，因此放到page buff的只会是L4 payload,而不包括头。这里就不需要复制，而是直接将数据放到page buff,接下来的图表示了有Scatter/Gather I/O的情况时，调用ip_append_data之前和之后的区别： 

 

Java代码  

1. struct skb_frag_struct {  
2.     struct page *page;  
3.     __u32 page_offset;  
4.     __u32 size;  
5. };  

这里可以看到nr_frags域来表示有多少个S/G I/O buffer在这个包中被使用。其实整个S/G I/O buffer相当于一个数组，每个元素都是一个skb_frag_t结构，而这个数组的大小就是nr_frags,最大的size是MAX_SKB_FRAGS. 

这里要注意，当一个新的帧的大小，大于当前页的剩余大小是，他会被分为两部分，一部分在当前页，一部分在新的页。 

没有 s/g I/O: 
它会复制数据到当前的data。 


4层可以调用ip_append_data多次，在flush这个buff之前。 

还有一个getfrag，我再说明下，ip_append_data的任务之一就是复制输入数据到它创建的帧，而不同的协议需要不同的复制操作。比如4层的check sum。有些4层协议就是不需要的。 
因此就有了这样一个虚函数，不同的协议实现自己的复制函数，然后传入到ip_append_data. 
这个函数其实也就是将用户空间的数据复制到内核空间。 
下面这个图就是一些协议实现的复制函数： 





接下来的这个图表示了ip_append_data的流程图： 


 

下来我们来看它的具体实现： 

Java代码  

1. int ip_append_data(struct sock *sk,  
2.            int getfrag(void *from, char *to, int offset, int len,  
3.                    int odd, struct sk_buff *skb),  
4.            void *from, int length, int transhdrlen,  
5.            struct ipcm_cookie *ipc, struct rtable *rt,  
6.            unsigned int flags)  
7. {  
8. ///取出取出相关的变量。  
9.     struct inet_sock *inet = inet_sk(sk);  
10.     struct sk_buff *skb;  
11.   
12.     struct ip_options *opt = NULL;  
13.     int hh_len;  
14.     int exthdrlen;  
15.     int mtu;  
16.     int copy;  
17.     int err;  
18.     int offset = 0;  
19.     unsigned int maxfraglen, fragheaderlen;  
20.     int csummode = CHECKSUM_NONE;  
21.   
22. ///如果只是探测路径则直接返回。  
23.     if (flags&MSG_PROBE)  
24.         return 0;  
25. ///当sk_write_queue 为空，意味着创建的是第一个ip帧。因此需要初始化一些相关域。  
26.     if (skb_queue_empty(&sk->sk_write_queue)) {  
27.         /* 
28.          * setup for corking. 
29.          */  
30. ///初始化cork的一些相关域。  
31.         opt = ipc->opt;  
32.         if (opt) {  
33.             if (inet->cork.opt == NULL) {  
34.                 inet->cork.opt = kmalloc(sizeof(struct ip_options) + 40, sk->sk_allocation);  
35.                 if (unlikely(inet->cork.opt == NULL))  
36.                     return -ENOBUFS;  
37.             }  
38.             memcpy(inet->cork.opt, opt, sizeof(struct ip_options)+opt->optlen);  
39.             inet->cork.flags |= IPCORK_OPT;  
40.             inet->cork.addr = ipc->addr;  
41.         }  
42.         dst_hold(&rt->u.dst);  
43.         inet->cork.fragsize = mtu = inet->pmtudisc == IP_PMTUDISC_PROBE ?  
44.                         rt->u.dst.dev->mtu :  
45.                         dst_mtu(rt->u.dst.path);  
46.         inet->cork.dst = &rt->u.dst;  
47.         inet->cork.length = 0;  
48.   
49.         sk->sk_sndmsg_page = NULL;  
50.         sk->sk_sndmsg_off = 0;  
51.         if ((exthdrlen = rt->u.dst.header_len) != 0) {  
52. ///加上扩展头和传输层的头的大小。  
53.             length += exthdrlen;  
54.             transhdrlen += exthdrlen;  
55.         }  
56.     } else {  
57.         rt = (struct rtable *)inet->cork.dst;  
58.         if (inet->cork.flags & IPCORK_OPT)  
59.             opt = inet->cork.opt;  
60. ///不是第一个帧，则需要把ipsec头和4层的伪头的大小赋值为0.(因为同一个sk，共享相同的头。  
61.         transhdrlen = 0;  
62.         exthdrlen = 0;  
63.         mtu = inet->cork.fragsize;  
64.     }  
65. ///得到2层头的大小（也就是预留2层头的大小).  
66.     hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);  
67. ///得到3层头的大小。  
68.     fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);  
69. ///ip包的大小。基于路由pmtu。  
70.     maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;  
71.   
72. ///由于ip包的最大大小为64kb(oxFFFF),因此拒绝大于这个数据包。  
73.     if (inet->cork.length + length > 0xFFFF - fragheaderlen) {  
74.         ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, mtu-exthdrlen);  
75.         return -EMSGSIZE;  
76.     }  
77.   
78.     /* 
79.      * transhdrlen > 0 means that this is the first fragment and we wish 
80.      * it won't be fragmented in the future. 
81.      */  
82. ///检测checksum是否需要硬件来做。  
83.     if (transhdrlen &&  
84.         length + fragheaderlen <= mtu &&  
85.         rt->u.dst.dev->features & NETIF_F_V4_CSUM &&  
86.         !exthdrlen)  
87.         csummode = CHECKSUM_PARTIAL;  
88.   
89.     inet->cork.length += length;  
90. ///检测长度是否大于mtu，以及是否是udp协议。然后进行udp分片。  
91.     if (((length> mtu) || !skb_queue_empty(&sk->sk_write_queue)) &&  
92.         (sk->sk_protocol == IPPROTO_UDP) &&  
93.         (rt->u.dst.dev->features & NETIF_F_UFO)) {  
94. ///进行udp分片。  
95.         err = ip_ufo_append_data(sk, getfrag, from, length, hh_len,  
96.                      fragheaderlen, transhdrlen, mtu,  
97.                      flags);  
98.         if (err)  
99.             goto error;  
100.         return 0;  
101.     }  
102.   
103.     if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)  
104.         goto alloc_new_skb;  
105.   
106. ///开始将数据复制到创建的帧。  
107.     while (length > 0) {  
108.         /* Check if the remaining data fits into current packet. */  
109.         copy = mtu - skb->len;  
110.   
111. ///空间不足时(也就是当前帧剩余的大小不够放入将要复制的数据).  
112.         if (copy < length)  
113.             copy = maxfraglen - skb->len;  
114. ///帧太大，需要切片。  
115.         if (copy <= 0) {  
116.   
117.             char *data;  
118.             unsigned int datalen;  
119.             unsigned int fraglen;  
120.             unsigned int fraggap;  
121.             unsigned int alloclen;  
122.             struct sk_buff *skb_prev;  
123. alloc_new_skb:  
124.             skb_prev = skb;  
125. ///检测上一个skb是否存在  
126.             if (skb_prev)  
127. ///存在取得他的fraggap(小于8字节的).这里要解释下fraggap.除了最后一个ip帧，所有的ip帧都必须使他的ip帧的负荷的大小为8字节的倍数。因此当kernel分配一个新的buffer时，他可能需要移动一些数据从前一个buffer的尾部到新的buffer的头部。  
128.                 fraggap = skb_prev->len - maxfraglen;  
129.             else  
130.                 fraggap = 0;  
131.   
132.             /* 
133.              * If remaining data exceeds the mtu, 
134.              * we know we need more fragment(s). 
135.              */  
136. ///得到数据长度  
137.             datalen = length + fraggap;  
138.             if (datalen > mtu - fragheaderlen)  
139.                 datalen = maxfraglen - fragheaderlen;  
140.             fraglen = datalen + fragheaderlen;  
141. ///如果flag为MSG_MORE并且设备设备不支持Scatter/Gather I/O.则需要分配一块等于mtu的内存。  
142.             if ((flags & MSG_MORE) &&  
143.                 !(rt->u.dst.dev->features&NETIF_F_SG))  
144.                 alloclen = mtu;  
145.             else  
146.                 alloclen = datalen + fragheaderlen;  
147.   
148.             /* The last fragment gets additional space at tail. 
149.              * Note, with MSG_MORE we overallocate on fragments, 
150.              * because we have no idea what fragment will be 
151.              * the last. 
152.              */  
153.             if (datalen == length + fraggap)  
154.                 alloclen += rt->u.dst.trailer_len;  
155.   
156. ///alloc相应的skb。  
157.             if (transhdrlen) {  
158.                 skb = sock_alloc_send_skb(sk,  
159.                         alloclen + hh_len + 15,  
160.                         (flags & MSG_DONTWAIT), &err);  
161.             } else {  
162.                 skb = NULL;  
163.                 if (atomic_read(&sk->sk_wmem_alloc) <=  
164.                     2 * sk->sk_sndbuf)  
165.                     skb = sock_wmalloc(sk,  
166.                                alloclen + hh_len + 15, 1,  
167.                                sk->sk_allocation);  
168.                 if (unlikely(skb == NULL))  
169.                     err = -ENOBUFS;  
170.             }  
171. ///检测是否成功  
172.             if (skb == NULL)  
173.                 goto error;  
174. ///设置校验位  
175.             skb->ip_summed = csummode;  
176.             skb->csum = 0;  
177.             skb_reserve(skb, hh_len);  
178.   
179. ///得到数据位置。  
180.             data = skb_put(skb, fraglen);  
181.             skb_set_network_header(skb, exthdrlen);  
182. ///得到传输层的头部。  
183.             skb->transport_header = (skb->network_header +  
184.                          fragheaderlen);  
185.             data += fragheaderlen;  
186. ///检测是否有fraggap.  
187.             if (fraggap) {  
188.                 skb->csum = skb_copy_and_csum_bits(  
189.                     skb_prev, maxfraglen,  
190.                     data + transhdrlen, fraggap, 0);  
191.                 skb_prev->csum = csum_sub(skb_prev->csum,  
192.                               skb->csum);  
193.                 data += fraggap;  
194.                 pskb_trim_unique(skb_prev, maxfraglen);  
195.             }  
196.   
197. ///得到所需要拷贝的数据的大小  
198.             copy = datalen - transhdrlen - fraggap;  
199. ///开始拷贝数据。  
200.             if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {  
201.                 err = -EFAULT;  
202.                 kfree_skb(skb);  
203.                 goto error;  
204.             }  
205.   
206.             offset += copy;  
207.             length -= datalen - fraggap;  
208.             transhdrlen = 0;  
209.             exthdrlen = 0;  
210.             csummode = CHECKSUM_NONE;  
211.   
212.             /* 
213.              * Put the packet on the pending queue. 
214.              */  
215. ///加这个包到write_queue队列。  
216.             __skb_queue_tail(&sk->sk_write_queue, skb);  
217.             continue;  
218.         }  
219.   
220.         if (copy > length)  
221.             copy = length;  
222.   
223. ///如果不支持Scatter/Gather I/O.则直接拷贝数据  
224.         if (!(rt->u.dst.dev->features&NETIF_F_SG)) {  
225.             unsigned int off;  
226.   
227.             off = skb->len;  
228.             if (getfrag(from, skb_put(skb, copy),  
229.                     offset, copy, off, skb) < 0) {  
230.                 __skb_trim(skb, off);  
231.                 err = -EFAULT;  
232.                 goto error;  
233.             }  
234.         } else {  
235. ///如果支持S/G I/O则开始进行相应操作  
236. ///i为当前已存储的个数。  
237.             int i = skb_shinfo(skb)->nr_frags;  
238. //取出skb_frag_t指针。  
239.             skb_frag_t *frag = &skb_shinfo(skb)->frags[i-1];  
240. ///得到当前的物理页。  
241.             struct page *page = sk->sk_sndmsg_page;  
242. ///得到当前的物理页的位移(也就是我们接下来要存储的位置的位移)  
243.             int off = sk->sk_sndmsg_off;  
244.             unsigned int left;  
245.   
246. ///如果有足够的空间则将数据放进相应的物理页的位置。  
247.             if (page && (left = PAGE_SIZE - off) > 0) {  
248. ///当剩余的空间不够放将要拷贝的数据时，则先将剩余的空间拷贝完毕。然后下次循环再进行拷贝剩下的。  
249.                 if (copy >= left)  
250.                     copy = left;  
251.                 if (page != frag->page) {  
252.                     if (i == MAX_SKB_FRAGS) {  
253.                         err = -EMSGSIZE;  
254.                         goto error;  
255.                     }  
256.                     get_page(page);  
257. ///填充页  
258.                     skb_fill_page_desc(skb, i, page, sk->sk_sndmsg_off, 0);  
259.                     frag = &skb_shinfo(skb)->frags[i];  
260.                 }  
261.             }   
262. ///检测是否存储空间已满。(此时说明page不存在或者，剩余大小威0，此时需要重新alloc一个物理页。  
263. else if (i < MAX_SKB_FRAGS) {  
264. ///检测所需拷贝的数据的大小是否大于页的大小。  
265.                 if (copy > PAGE_SIZE)  
266.                     copy = PAGE_SIZE;  
267. ///则新分配一个页。  
268.                 page = alloc_pages(sk->sk_allocation, 0);  
269.                 if (page == NULL)  {  
270.                     err = -ENOMEM;  
271.                     goto error;  
272.                 }  
273.                 sk->sk_sndmsg_page = page;  
274.                 sk->sk_sndmsg_off = 0;  
275.   
276.                 skb_fill_page_desc(skb, i, page, 0, 0);  
277.                 frag = &skb_shinfo(skb)->frags[i];  
278.             } else {  
279.                 err = -EMSGSIZE;  
280.                 goto error;  
281.             }  
282. ///调用getfrag,填充相应的数据包(4层传递下来的数据)  
283.             if (getfrag(from, page_address(frag->page)+frag->page_offset+frag->size, offset, copy, skb->len, skb) < 0) {  
284.                 err = -EFAULT;  
285.                 goto error;  
286.             }  
287.             sk->sk_sndmsg_off += copy;  
288.             frag->size += copy;  
289.             skb->len += copy;  
290.             skb->data_len += copy;  
291.             skb->truesize += copy;  
292.             atomic_add(copy, &sk->sk_wmem_alloc);  
293.         }  
294. ///计算下次需要再拷贝的。。  
295.         offset += copy;  
296.         length -= copy;  
297.     }  
298.   
299.     return 0;  
300.   
301. error:  
302.     inet->cork.length -= length;  
303.     IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);  
304.     return err;  
305. }  

在上面的代码中，我们可以看到同一个物理页，有可能被sk_sndmsg_page和skb_frag_t 所共享，可以看下下面的图： 


 


接下来来看ip_append_page，这个函数比较简单，我们大概分析下就可以了。 

我们知道内核提供给用户空间的一个零拷贝的接口sendfile.这个接口只能当设备提供Scatter/Gather I/O的时候，才能使用。而它的实现就是基于ip_append_page这个函数来实现的。如果设备不支持S/G I/O,ip_append_page会直接返回错误。 

它的逻辑实现和ip_append_page最后面那段实现很相似，不过有些不同，当加一个新的帧到page时，ip_append_page它会merge新的和也在当前页的前一个帧。它会通过调用skb_can_coalesce来进行检测这个。然后当merge是可能的，它就会update前一个帧的长度。 
当merge是不可能的时候，处理和ip_append_data相似。 
下面就是ip_append_page的一些代码片段： 

Java代码  

1. if (skb_can_coalesce(skb, i, page, offset)) {  
2.             skb_shinfo(skb)->frags[i-1].size += len;  
3.         } else if (i < MAX_SKB_FRAGS) {  
4.             get_page(page);  
5.             skb_fill_page_desc(skb, i, page, offset, len);  
6.         } else {  
7.             err = -EMSGSIZE;  
8.             goto error;  
9.         }  

ip_append_page只被udp使用。tcp不使用ip_append_data和ip_push_pending_frams是因为它把一些逻辑放到tcp_sendmsg来实现了。因此相似的，0拷贝接口，tcp不使用ip_append_page是因为他在do_tcp_sendpage中实现了相同的逻辑。 

最后我们来看ip_push_pending_frams函数。 

这个函数相当于一个notify函数，当4层决定传输帧到ip层的时候，他就需要调用这个函数.通过前面我们知道此时所有的数据(如果不支持Scatter/Gather I/O),都在sk_write_queue中。 

这个函数要做的其实很简单，就是从sk_write_queue中取出数据，加上ip头，然后通过dst_output发送给3层。 

当数据从sk_write_queue从移除后，加入到frag_list链表中。 
下面这张图表示了从sk_write_queue中移除buffer之前和之后的区别(没有考虑Scatter/Gather I/O). 


 


接下来来看它的实现： 

Java代码  

1. int ip_push_pending_frames(struct sock *sk)  
2. {  
3. ///初始化一些数据  
4.     struct sk_buff *skb, *tmp_skb;  
5.     struct sk_buff **tail_skb;  
6.     struct inet_sock *inet = inet_sk(sk);  
7.     struct net *net = sock_net(sk);  
8.     struct ip_options *opt = NULL;  
9.     struct rtable *rt = (struct rtable *)inet->cork.dst;  
10.     struct iphdr *iph;  
11.     __be16 df = 0;  
12.     __u8 ttl;  
13.     int err = 0;  
14. ///取得第一个buffer  
15.     if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)  
16.         goto out;  
17. ///得到他的frag_list.  
18.     tail_skb = &(skb_shinfo(skb)->frag_list);  
19.   
20.     /* move skb->data to ip header from ext header */  
21.     if (skb->data < skb_network_header(skb))  
22.         __skb_pull(skb, skb_network_offset(skb));  
23. ///开始遍历并取出所有的buffer到frag_list.  
24.     while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {  
25.         __skb_pull(tmp_skb, skb_network_header_len(skb));  
26.         *tail_skb = tmp_skb;  
27.         tail_skb = &(tmp_skb->next);  
28.         skb->len += tmp_skb->len;  
29.         skb->data_len += tmp_skb->len;  
30.         skb->truesize += tmp_skb->truesize;  
31.         __sock_put(tmp_skb->sk);  
32.         tmp_skb->destructor = NULL;  
33.         tmp_skb->sk = NULL;  
34.     }  
35.   
36.     /* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow 
37.      * to fragment the frame generated here. No matter, what transforms 
38.      * how transforms change size of the packet, it will come out. 
39.      */  
40.     if (inet->pmtudisc < IP_PMTUDISC_DO)  
41.         skb->local_df = 1;  
42.   
43.     /* DF bit is set when we want to see DF on outgoing frames. 
44.      * If local_df is set too, we still allow to fragment this frame 
45.      * locally. */  
46.     if (inet->pmtudisc >= IP_PMTUDISC_DO ||  
47.         (skb->len <= dst_mtu(&rt->u.dst) &&  
48.          ip_dont_fragment(sk, &rt->u.dst)))  
49. ///标记ip头不要被切片。  
50.     df = htons(IP_DF);  
51. ///如果在头中包含ip option,则给option赋值，然后下面会处理这个option。  
52.     if (inet->cork.flags & IPCORK_OPT)  
53.         opt = inet->cork.opt;  
54. ///如果是多播，则赋值多播的ttl  
55.     if (rt->rt_type == RTN_MULTICAST)  
56.         ttl = inet->mc_ttl;  
57.     else  
58.         ttl = ip_select_ttl(inet, &rt->u.dst);  
59.   
60. ///得到ip头的指针。  
61.     iph = (struct iphdr *)skb->data;  
62. ///开始初始化ip头。  
63.     iph->version = 4;  
64.     iph->ihl = 5;  
65.     if (opt) {  
66.         iph->ihl += opt->optlen>>2;  
67.         ip_options_build(skb, opt, inet->cork.addr, rt, 0);  
68.     }  
69.     iph->tos = inet->tos;  
70.     iph->frag_off = df;  
71. ///得到ip包的id。  
72.     ip_select_ident(iph, &rt->u.dst, sk);  
73.     iph->ttl = ttl;  
74.     iph->protocol = sk->sk_protocol;  
75.     iph->saddr = rt->rt_src;  
76.     iph->daddr = rt->rt_dst;  
77.   
78.     skb->priority = sk->sk_priority;  
79.     skb->mark = sk->sk_mark;  
80.     skb->dst = dst_clone(&rt->u.dst);  
81.   
82. ///如果协议是ICMP则进行相关处理。  
83.     if (iph->protocol == IPPROTO_ICMP)  
84.         icmp_out_count(net, ((struct icmphdr *)  
85.             skb_transport_header(skb))->type);  
86.   
87.     /* Netfilter gets whole the not fragmented skb. */  
88. ///输出到4层，这个函数上面有介绍过，会通过一个netfilter的hook.  
89.     err = ip_local_out(skb);  
90.     if (err) {  
91.         if (err > 0)  
92.             err = inet->recverr ? net_xmit_errno(err) : 0;  
93.         if (err)  
94.             goto error;  
95.     }  
96.   
97. out:  
98.     ip_cork_release(inet);  
99.     return err;  
100.   
101. error:  
102.     IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);  
103.     goto out;  
104. }  

接下来我们会来简要的介绍4层使用上面的函数接口和3层如何把帧传递给2层的接口： 
先来看udp_sendmsg的代码片段： 

Java代码  

1. up->len += ulen;  
2.     getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;  
3. ///将要传输的包交给ip_append_data来处理  
4.     err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,  
5.             sizeof(struct udphdr), &ipc, rt,  
6.             corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);  
7.     if (err)  
8.         udp_flush_pending_frames(sk);  
9.     else if (!corkreq)  
10. ///如果需要传递给3层，则调用udp_push_pending_frames,这个函数是对ip_push_pending_frames的简单封装。  
11.         err = udp_push_pending_frames(sk);  
12.     else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))  
13.         up->pending = 0;  
14.     release_sock(sk);  

我们现在知道4层到3层之后，最终通过dst_output来把帧进行输出，这个函数在单播的情况下，是被实例化为ip_output.这里和前面的netfilter一样，还存在一个ip_output_finish方法，当通过netfilter hook后，如果这个包可以被netfilter放过，那么帧就会传递到ip_output_finish方法，然后再调用ip_output_finish2方法。而最终dev_queue_xmit(前面的blog有介绍，也就是2层的传输方法)会被调用(这里是通过hh->hh_output方法或者fst->neighbour->output 2个虚函数)来传输。 

Java代码  

1. static inline int ip_finish_output2(struct sk_buff *skb)  
2. {  
3. .........................................  
4.   
5.     if (dst->hh)  
6.         return neigh_hh_output(dst->hh, skb);  
7.     else if (dst->neighbour)  
8.         return dst->neighbour->output(skb);  
9. ...................................  
10. }