設備收發包之netif_receive_skb

在設備驅動收包之后，會通過netif_receive_skb將收取的包，按照注冊的協議回調，傳遞到上層進行處理；

/* 將skb傳遞到上層 */
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;

    /* 記錄收包時間，netdev_tstamp_prequeue為0，表示可能有包延遲 */
    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);

    /* 
        留下一個節點，最后一次向上層傳遞時，
        不需要在inc引用，回調中會free
        這樣相當於少調用了一次free
    */
    pt_prev = NULL;

another_round:

    /* 接收設備索引號 */
    skb->skb_iif = skb->dev->ifindex;

    /* 處理包數統計 */
    __this_cpu_inc(softnet_data.processed);

    /* vlan包，則去掉vlan頭 */
    if (skb->protocol == cpu_to_be16(ETH_P_8021Q) ||
        skb->protocol == cpu_to_be16(ETH_P_8021AD)) {

        /*
            這里改了三層協議，protocol指向ip等
            another_round不會再走這里
        */
        skb = skb_vlan_untag(skb);
        if (unlikely(!skb))
            goto out;
    }

    /* 不對數據包進行分類 */
    if (skb_skip_tc_classify(skb))
        goto skip_classify;

    /* prmemalloc */
    if (pfmemalloc)
        goto skip_taps;


    /* 下面兩個是未(指定)設備的所有協議傳遞的上層傳遞 */


    /* 如抓包程序未指定設備 */    
    /* 進行未指定設備的全局鏈表對應協議的skb上層傳遞 */
    list_for_each_entry_rcu(ptype, &ptype_all, list) {
        if (pt_prev)
            ret = deliver_skb(skb, pt_prev, orig_dev);
        pt_prev = ptype;
    }

    /* 如抓包程序指定了設備 */
    /* 進行指定設備的協議鏈表的skb上層傳遞 */
    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
    skb_reset_tc(skb);
skip_classify:

    /* 不支持使用pfmemalloc */
    if (pfmemalloc && !skb_pfmemalloc_protocol(skb))
        goto drop;

    /* 如果是vlan包 */
    if (skb_vlan_tag_present(skb)) {
        /* 處理prev */
        if (pt_prev) {
            ret = deliver_skb(skb, pt_prev, orig_dev);
            pt_prev = NULL;
        }

        /* 根據實際的vlan設備調整信息，再走一遍 */
        if (vlan_do_receive(&skb))
            goto another_round;
        else if (unlikely(!skb))
            goto out;
    }

    /* 如果有注冊handler，那么調用，比如網橋模塊 */
    rx_handler = rcu_dereference(skb->dev->rx_handler);
    if (rx_handler) {
        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;
            /* 修改了skb->dev，在處理一次 */
        case RX_HANDLER_ANOTHER:
            goto another_round;
            /* 精確傳遞到ptype->dev == skb->dev */
        case RX_HANDLER_EXACT:
            deliver_exact = true;
            /* 正常傳遞即可 */
        case RX_HANDLER_PASS:
            break;
        default:
            BUG();
        }
    }

    /* 還有vlan標記，說明找不到vlanid對應的設備 */
    if (unlikely(skb_vlan_tag_present(skb))) {
        /* 存在vlanid，則判定是到其他設備的包 */
        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;

    /* deliver only exact match when indicated */
    /* 未設置精確發送，則向未指定設備的指定協議全局發送一份 */
    if (likely(!deliver_exact)) {
        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);
    }

    if (pt_prev) {
        if (unlikely(skb_orphan_frags(skb, GFP_ATOMIC)))
            goto drop;
        else
            /*
                使用pt_prev這里就不需要deliver_skb來inc應用數了
                func執行內部會free，減少了一次skb_free
            */
            /* 傳遞到上層*/
            ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
    } 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;
    }

out:
    return ret;
}