By

文章目录

在设备驱动收包之后，会通过netif_receive_skb将收取的包，按照注册的协议回调，传递到上层进行处理；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
/* 将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;
}
文章目录