IP输出 之 ip_output、ip_finish_output、ip_finish_output2

概述

ip_output-设置输出设备和协议，然后经过POST_ROUTING钩子点，最后调用ip_finish_output；

ip_finish_output-对skb进行分片判断，需要分片，则分片后输出，不需要分片则知直接输出；

ip_finish_output2-对skb的头部空间进行检查，看是否能够容纳下二层头部，若空间不足，则需要重新申请skb；然后，获取邻居子系统，并通过邻居子系统输出；

源码分析

 int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
     struct net_device *dev = skb_dst(skb)->dev;

     IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);

     /* 设置输出设备和协议 */
     skb->dev = dev;
     skb->protocol = htons(ETH_P_IP);

     /* 经过NF的POST_ROUTING钩子点 */
     return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
                 net, sk, skb, NULL, dev,
                 ip_finish_output,
                 !(IPCB(skb)->flags & IPSKB_REROUTED));
 }

 static int ip_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
     unsigned int mtu;
     int ret;

     ret = BPF_CGROUP_RUN_PROG_INET_EGRESS(sk, skb);
     if (ret) {
         kfree_skb(skb);
         return ret;
     }

 #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
     /* Policy lookup after SNAT yielded a new policy */
     if (skb_dst(skb)->xfrm) {
         IPCB(skb)->flags |= IPSKB_REROUTED;
         return dst_output(net, sk, skb);
     }
 #endif
     /* 获取mtu */
     mtu = ip_skb_dst_mtu(sk, skb);

     /* 是gso，则调用gso输出 */
     if (skb_is_gso(skb))
         return ip_finish_output_gso(net, sk, skb, mtu);

     /* 长度>mtu或者设置了IPSKB_FRAG_PMTU标记，则分片 */
     if (skb->len > mtu || (IPCB(skb)->flags & IPSKB_FRAG_PMTU))
         return ip_fragment(net, sk, skb, mtu, ip_finish_output2);

     /* 输出数据包 */
     return ip_finish_output2(net, sk, skb);
 }

 static int ip_finish_output2(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
     struct dst_entry *dst = skb_dst(skb);
     struct rtable *rt = (struct rtable *)dst;
     struct net_device *dev = dst->dev;
     unsigned int hh_len = LL_RESERVED_SPACE(dev);
     struct neighbour *neigh;
     u32 nexthop;

     if (rt->rt_type == RTN_MULTICAST) {
         IP_UPD_PO_STATS(net, IPSTATS_MIB_OUTMCAST, skb->len);
     } else if (rt->rt_type == RTN_BROADCAST)
         IP_UPD_PO_STATS(net, IPSTATS_MIB_OUTBCAST, skb->len);

     /* Be paranoid, rather than too clever. */
     /* skb头部空间不能存储链路头 */
     if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
         struct sk_buff *skb2;

         /* 重新分配skb */
         skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
         if (!skb2) {
             kfree_skb(skb);
             return -ENOMEM;
         }
         /* 关联控制块 */
         if (skb->sk)
             skb_set_owner_w(skb2, skb->sk);

         /* 释放skb */
         consume_skb(skb);

         /* 指向新的skb */
         skb = skb2;
     }

     if (lwtunnel_xmit_redirect(dst->lwtstate)) {
         int res = lwtunnel_xmit(skb);

         if (res <  || res == LWTUNNEL_XMIT_DONE)
             return res;
     }

     rcu_read_lock_bh();
     /* 获取下一跳 */
     nexthop = (__force u32) rt_nexthop(rt, ip_hdr(skb)->daddr);
     /* 获取邻居子系统 */
     neigh = __ipv4_neigh_lookup_noref(dev, nexthop);

     /* 创建邻居子系统 */
     if (unlikely(!neigh))
         neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);

     /* 成功 */
     if (!IS_ERR(neigh)) {
         int res;

         /* 更新路由缓存确认 */
         sock_confirm_neigh(skb, neigh);

         /* 通过邻居子系统输出 */
         res = neigh_output(neigh, skb);

         rcu_read_unlock_bh();
         return res;
     }
     rcu_read_unlock_bh();

     net_dbg_ratelimited("%s: No header cache and no neighbour!\n",
                 __func__);
     /* 释放skb */
     kfree_skb(skb);
     return -EINVAL;
 }