链路层输入报文的处理

static struct packet_type ip_packet_type __read_mostly = {
    .type = cpu_to_be16(ETH_P_IP),
    .func = ip_rcv,
};

static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
{
    struct packet_type *ptype, *pt_prev;
    rx_handler_func_t *rx_handler;
    struct net_device *orig_dev;
    bool deliver_exact = false;
    int ret = NET_RX_DROP;
    __be16 type;

    net_timestamp_check(!netdev_tstamp_prequeue, skb);

    trace_netif_receive_skb(skb);

    orig_dev = skb->dev;

    skb_reset_network_header(skb);
    if (!skb_transport_header_was_set(skb))
        skb_reset_transport_header(skb);
    skb_reset_mac_len(skb);

    pt_prev = NULL;

another_round:
    skb->skb_iif = skb->dev->ifindex;

    __this_cpu_inc(softnet_data.processed);/* 增加本cpu处理过的数据包个数 */  
     /*解析8021 q 协议*/
    if (skb->protocol == cpu_to_be16(ETH_P_8021Q) ||
        skb->protocol == cpu_to_be16(ETH_P_8021AD)) {
        skb = skb_vlan_untag(skb);
        if (unlikely(!skb))
            goto out;
    }
/* 入口流量控制 */  
#ifdef CONFIG_NET_CLS_ACT
    if (skb->tc_verd & TC_NCLS) {
        skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
        goto ncls;
    }
#endif

    if (pfmemalloc)
        goto skip_taps;
 /*    
    po->prot_hook.func = packet_rcv;
    if (sock->type == SOCK_PACKET)
        po->prot_hook.func = packet_rcv_spkt;
    */
    //在net_dev_init中初始化
        /*注意这里并没有要求ptype->type == type，所以接收到的包只要有注册ETH_P_ALL协议
        ，所有的包都会走到deliver_skb
           遍历嗅探器(ETH_P_ALL)链表ptype_all。对于每个注册的sniffer， 
     * 调用它的处理函数packet_type->func()，例如tcpdump。 
     */  
    list_for_each_entry_rcu(ptype, &ptype_all, list) {
        if (pt_prev)
            ret = deliver_skb(skb, pt_prev, orig_dev);
        pt_prev = ptype;
    }
/* //设备上注册ptype_all，做相应的处理，更加精细的控制 **/
    list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) {
        if (pt_prev)
            ret = deliver_skb(skb, pt_prev, orig_dev);
        pt_prev = ptype;
    }

skip_taps:
#ifdef CONFIG_NET_INGRESS
    if (static_key_false(&ingress_needed)) {
        skb = sch_handle_ingress(skb, &pt_prev, &ret, orig_dev);
        if (!skb)
            goto out;

        if (nf_ingress(skb, &pt_prev, &ret, orig_dev) < 0)
            goto out;
    }
#endif
#ifdef CONFIG_NET_CLS_ACT
    skb->tc_verd = 0;
ncls:
#endif
    if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
        goto drop;
/*处理8021q**/
    if (skb_vlan_tag_present(skb)) {
        if (pt_prev) {
            ret = deliver_skb(skb, pt_prev, orig_dev);
            pt_prev = NULL;
        }
        if (vlan_do_receive(&skb))
            goto another_round;
        else if (unlikely(!skb))
            goto out;
    }
/*内核提供了netdev_rx_handler_register接口函数向接口注册rx_handler 
比如为网桥下的接口注册br_handle_frame函数 
为bonding接口注册bond_handle_frame函数
网桥的处理包括向上层提交和转发 
发往本地的报文会修改入接口为网桥虚接口如br0 
调用netif_receive_skb重新进入协议栈处理 
对于上层协议栈见到的只有桥虚接口 
需要转发的报文根据转发表进行单播或广播发送 */
//设备rx_handler，加入OVS时会注册为OVS的入口函数??
    rx_handler = rcu_dereference(skb->dev->rx_handler);
    if (rx_handler) {//执行rx_handler处理，例如进入OVS，OVS不支持报头中携带vlan的报文??
        if (pt_prev) {
            ret = deliver_skb(skb, pt_prev, orig_dev);
            pt_prev = NULL;
        }
        switch (rx_handler(&skb)) {
        case RX_HANDLER_CONSUMED:
            ret = NET_RX_SUCCESS;//数据包已成功接收，不需要再处理
            goto out;
        case RX_HANDLER_ANOTHER://当rx_handler改变过skb->dev时，在接收回路中再一次处理。
            goto another_round;
        case RX_HANDLER_EXACT://不使用匹配的方式，精确传递。
            deliver_exact = true;
        case RX_HANDLER_PASS://忽略rx_handler的影响。
            break;
        default:
            BUG();
        }
    }

    if (unlikely(skb_vlan_tag_present(skb))) {
        if (skb_vlan_tag_get_id(skb))
            skb->pkt_type = PACKET_OTHERHOST;
        /* Note: we might in the future use prio bits
         * and set skb->priority like in vlan_do_receive()
         * For the time being, just ignore Priority Code Point
         */
        skb->vlan_tci = 0;
    }

   /*
    最后 type = skb->protocol; &ptype_base[ntohs(type)&15]
        //处理ptype_base[ntohs(type)&15]上的所有的 packet_type->func()
        //根据第二层不同协议来进入不同的钩子函数，重要的有：ip_rcv() arp_rcv()
        ip_recv见inet_init里面的dev_add_pack(&ip_packet_type);
    */
    type = skb->protocol; //skb->protocol用来表示此SKB包含的数据所支持的L3层协议是什么. 如ox0800代表IP，0x0806代表ARP 在驱动程序中已经获取了该值

    /* deliver only exact match when indicated */
    if (likely(!deliver_exact)) {//根据全局定义的协议处理报文??//如果前面判段是精确发送方式，那么把nulll_or_dev设置成精确传送的设备
        deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
                       &ptype_base[ntohs(type) &
                           PTYPE_HASH_MASK]);
    }

    deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
                   &orig_dev->ptype_specific);?//根据设备上注册的协议进行处理??

    if (unlikely(skb->dev != orig_dev)) {//如果设备发生变化，那么还需要针对新设备的注册协议进行处理??
        deliver_ptype_list_skb(skb, &pt_prev, orig_dev, type,
                       &skb->dev->ptype_specific);
    }


/***‘
1、vlan报文的处理，主要是循环把vlan头剥掉，如果qinqxxxxx场景，两个vlan都会被剥掉；
2、交给rx_handler处理，例如OVS、linux bridge等；
3、ptype_all处理，例如抓包程序、raw socket等；
4、ptype_base处理，交给协议栈处理，例如ip、arp、rarp等；
*/
    if (pt_prev) {
        if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
            goto drop;
        else
            ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);?//调用协议处理ip_rcv()   arp_rcv()
    } else {
drop:
        if (!deliver_exact)
            atomic_long_inc(&skb->dev->rx_dropped);
        else
            atomic_long_inc(&skb->dev->rx_nohandler);
        kfree_skb(skb);
        /* Jamal, now you will not able to escape explaining
         * me how you were going to use this. :-)
         */
        ret = NET_RX_DROP;
    }

/**
内核提供了netdev_rx_handler_register接口函数向接口注册rx_handler 
比如为网桥下的接口注册br_handle_frame函数 
为bonding接口注册bond_handle_frame函数 
这相对于老式的网桥处理更灵活 
有了这个机制也可以在模块中自行注册处理函数 
? 
网桥的处理包括向上层提交和转发 
发往本地的报文会修改入接口为网桥虚接口如br0 
调用netif_receive_skb重新进入协议栈处理 
对于上层协议栈见到的只有桥虚接口 
需要转发的报文根据转发表进行单播或广播发送 
netfilter在网桥的处理路径中从br_handle_frame到br_dev_queue_push_xmit设置了5个hook点 
根据nf_call_iptables的配置还会经过NFPROTO_IPV4的hook点等 
内核注册的由br_nf_ops数组中定义 
可在模块中自行向NFPROTO_BRIDGE族的几个hook点注册函数 
ebtables在netfilter框架NFPROTO_BRIDGE中实现了桥二层过滤机制 
配合应用程序ebtables可在桥下自定义相关规则 
? 
处理完接口上的rx_handler后便根据具体的3层协议类型在ptype_base中寻找处理函数 
比如ETH_P_IP则调用ip_rcv，ETH_P_IPV6则调用ipv6_rcv 
这些函数都由dev_add_pack注册 
可在模块中自定义协议类型处理函数 
如果重复定义相同协议的处理函数则要注意报文的修改对后续流程的影响 
? 
IP报文进入ip_rcv后进行简单的检查便进入路由选择 
根据路由查找结果调用ip_local_deliver向上层提交或调用ip_forward进行转发 
向上层提交前会进行IP分片的重组 
在ip_local_deliver_finish中会根据报文中4层协议类型调用对应的处理函数 
处理函数由接口函数inet_add_protocol注册 
针对TCP或UDP进行不同处理，最后唤醒应用程序接收数据 
向外发送和转发数据经由ip_output函数 
包括IP的分片，ARP学习，MAC地址的修改或填充等 
netfilter在从ip_rcv到ip_output间设置了5个hook点 
向各个点的链表中注册处理函数或使用iptables工具自定义规则 
实现报文处理的行为控制 
*/
out:
    return ret;
}

net/core/dev.c
static inline int deliver_skb(struct sk_buff *skb,
                  struct packet_type *pt_prev,
                   struct net_device *orig_dev)
 {
//在接收端要将分片的数据包重组，这里判断是否因缺少分片包而导致一个skb成为一个孤儿skb。显然是不太可能是孤儿进
//程的,所以这里使用了unlikely知道gcc编译器优化程序，以减少指令流水被打断的概率。
    if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))   
         return -ENOMEM;
    atomic_inc(&skb->users);  //增加skb的使用者计数器
     return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);  
 }