【网络知识】二层桥转发蓝图

一、看一张桥转发时函数调用的一个基本蓝图。

这张图中，简单的展示了，数据的接收和发送，其中还包括netfilet的钩子点所处的位置。

需要说明的是：
1）.我们先暂时忽略数据包从一开始是怎么从驱动进入到netif_receive_skb的，因为这个暂时不影响我们理解这幅图的流程。
2）.由于桥转发的篇幅较大，图中没有标示出，数据包中途被丢弃的情况。约定数据包会发送成功。

现在数据包(skb)已经准备好了装备要闯关了

1.首先skb从驱动经过繁杂的路线走到了netif_receive_skb这个函数中经过一些小波折到达__netif_receive_skb_core中时遇到了第一个十字路口是看了看自己有没有skb->dev->rx_handler(注1)这个装备，如果有，则进入br_handle_frame(注2).如果没有则直接上协议栈。

  注1：桥下的设备注册过rx_handler函数，所以数据包会进入桥，br_pass_frame_up函数将原先的设备换成了桥设备， 而桥设备没有注册过rx_handler函数，所以数据包不会二次进入桥。 
  注2：br_handle_frame我们在前几节提到过，是skb进入桥的入口函数，在br_add_if的时候会注册该函数。

2.skb注定要经历一番劫难，刚进入br_handle_frame又将陷入两难境地，此时有两个入口，这两个是netfilter设下的连个hook点，分别是，NF_BR_PRE_ROUTING，和NF_BR_LOCAL_IN，两种路径，如果数据包只想去本地，则会选择NF_BR_LOCAL_IN入口，然后发往本地，如果暂时还确定不了，则先进入NF_BR_PRE_ROUTING入口.

3.进入NF_BR_PRE_ROUTING入口后，会遇到br_handle_frame_finish函数，这个函数决定了skb的何去何从

扫描二维码关注公众号，回复： 3295840 查看本文章

(1)如果是转发，则在经过NF_BR_FORWARD钩子点进入转发阶段的障碍，最后在进入NF_BR_POST_ROUTING，以及最终的dev_queue_xmit，实现最终转发。

(2)如果发往本地则重新进入NF_BR_LOCAL_IN最后在进入netif_receive_skb，进行转发。

skb在经过目前口述的磨练最终得以释放。

4.如果是如果是本地发出的数据包，经过NF_BR_LOCAL_OUT钩子点然后进入最后阶段的NF_BR_POST_ROUTING，进行相应的转发。

二、我们看看数据包如何在桥中进行转发的一些动作。

  首先，上节的大蓝图中，标识除了，数据包是如何进入桥的，有一个很重要的函数br_handle_frame这个函数的初始注册地点是在桥添加接口的时候，注册在桥某一个接口上

[cpp] view plain copy

1. int br_add_if(struct net_bridge *br, struct net_device *dev)  
2. {  
3.     ........  
4.     /*注册设备接收帧函数*/  
5.     err = netdev_rx_handler_register(dev, br_handle_frame, p);  
6.     ........  
7. }  

其次，那么__netif_receive_skb_core是怎样让数据包进入桥的呢？我们看看上面提到的netdev_rx_handler_register函数，具体做了什么

[cpp] view plain copy

1. int netdev_rx_handler_register(struct net_device *dev,  
2.                    rx_handler_func_t *rx_handler,  
3.                    void *rx_handler_data)  
4. {  
5.     ASSERT_RTNL();  
6.   
7.     if (dev->rx_handler)  
8.         return -EBUSY;  
9.     /* Note: rx_handler_data must be set before rx_handler */  
10.     /*将dev->rx_handler_data，指向rx_handler_data(上面的p是桥端口信息)*/  
11.     rcu_assign_pointer(dev->rx_handler_data, rx_handler_data);  
12.     /*将dev->rx_handle指针指向rx_handler*/  
13.     rcu_assign_pointer(dev->rx_handler, rx_handler);  
14.   
15.     return 0;  
16. }  

看完这个函数，我们就明白了为什么在__netif_receive_skb_core中可以用skb->dev->rx_handle将数据包传入br_handle_frame函数，也就是将数据包传入了桥。

值得注意的是：上面的dev是桥下的设备，不是桥设备，桥设备(比如br0)是没有注册rx_handle这个函数的

好，了解到，桥的注册函数和如何接收数据包后，然后一起来看看br_handle_frame是如何操作的

[cpp] view plain copy

1. /* 
2.  * Return NULL if skb is handled 
3.  * note: already called with rcu_read_lock 
4.  */  
5. rx_handler_result_t br_handle_frame(struct sk_buff **pskb)  
6. {  
7.     struct net_bridge_port *p;  
8.     struct sk_buff *skb = *pskb;  
9.     const unsigned char *dest = eth_hdr(skb)->h_dest;  
10.     br_should_route_hook_t *rhook;  
11.   
12.     if (unlikely(skb->pkt_type == PACKET_LOOPBACK))  
13.         return RX_HANDLER_PASS;  
14.     /*判断是否是有效的mac地址，即不是多播地址也不是全00地址*/  
15.     if (!is_valid_ether_addr(eth_hdr(skb)->h_source))  
16.         goto drop;  
17.     /*判断是否是共享数据包，若果是则clone该数据包*/  
18.     skb = skb_share_check(skb, GFP_ATOMIC);  
19.     if (!skb)  
20.         return RX_HANDLER_CONSUMED;  
21.     /*获取数据包网桥端口的一些信息*/  
22.     p = br_port_get_rcu(skb->dev);  
23.     /*BPDU是网桥之间交流的报文，目标mac是 01:80:C2:00:00:00*/  
24.     if (unlikely(is_link_local_ether_addr(dest))) {  
25.         u16 fwd_mask = p->br->group_fwd_mask_required;  
26.   
27.         /* 
28.          * See IEEE 802.1D Table 7-10 Reserved addresses 
29.          * 
30.          * Assignment               Value 
31.          * Bridge Group Address     01-80-C2-00-00-00 
32.          * (MAC Control) 802.3      01-80-C2-00-00-01 
33.          * (Link Aggregation) 802.3 01-80-C2-00-00-02 
34.          * 802.1X PAE address       01-80-C2-00-00-03 
35.          * 
36.          * 802.1AB LLDP         01-80-C2-00-00-0E 
37.          * 
38.          * Others reserved for future standardization 
39.          */  
40.         switch (dest[5]) {  
41.         case 0x00:  /* Bridge Group Address */  
42.             /* If STP is turned off, 
43.                then must forward to keep loop detection */  
44.             if (p->br->stp_enabled == BR_NO_STP ||  
45.                 fwd_mask & (1u << dest[5]))  
46.                 goto forward;  
47.             *pskb = skb;  
48.             __br_handle_local_finish(skb);  
49.             return RX_HANDLER_PASS;  
50.   
51.         case 0x01:  /* IEEE MAC (Pause) */  
52.             goto drop;  
53.   
54.         case 0x0E:  /* 802.1AB LLDP */  
55.             fwd_mask |= p->br->group_fwd_mask;  
56.             if (fwd_mask & (1u << dest[5]))  
57.                 goto forward;  
58.             *pskb = skb;  
59.             __br_handle_local_finish(skb);  
60.             return RX_HANDLER_PASS;  
61.   
62.         default:  
63.             /* Allow selective forwarding for most other protocols */  
64.             fwd_mask |= p->br->group_fwd_mask;  
65.             if (fwd_mask & (1u << dest[5]))  
66.                 goto forward;  
67.         }  
68.   
69.         /* Deliver packet to local host only */  
70.         NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, dev_net(skb->dev),  
71.             NULL, skb, skb->dev, NULL, br_handle_local_finish);  
72.         return RX_HANDLER_CONSUMED;  
73.     }  
74.   
75. forward:  
76.     switch (p->state) {  
77.     case BR_STATE_FORWARDING:  
78.         /*ebtables获取路由的hook点*/  
79.         rhook = rcu_dereference(br_should_route_hook);  
80.         if (rhook) {/*如果是转发状态，则转发数据包，然后返回*/  
81.             if ((*rhook)(skb)) {  
82.                 *pskb = skb;  
83.                 return RX_HANDLER_PASS;  
84.             }  
85.             dest = eth_hdr(skb)->h_dest;  
86.         }  
87.         /* fall through */  
88.     case BR_STATE_LEARNING:  
89.         /*目的地址是否是设备链路层地址 */  
90.         if (ether_addr_equal(p->br->dev->dev_addr, dest))  
91.             skb->pkt_type = PACKET_HOST;  
92.         /*将数据包送入数据帧处理函数br_handle_frame_finish*/  
93.         NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING,  
94.             dev_net(skb->dev), NULL, skb, skb->dev, NULL,  
95.             br_handle_frame_finish);  
96.         break;  
97.     default:  
98. drop:  
99.         kfree_skb(skb);  
100.     }  
101.     return RX_HANDLER_CONSUMED;  
102. }  

在br_handle_frame主要做一件事，就是将数据包放进那个钩子点。

说明：br_handle_frame函数中有两个hook函数，br_handle_local_finish和br_handle_frame_finish这两个函数只有在netfilter因其他原因没有丢弃或者消化该帧时才会被调用，ebtables也能查看帧。ebtables是一个架构，能提供一些netfilter所没有的提供的额外功能，尤其是，ebtables可以过滤和修改任何类型的帧，而非仅限于那些携带ip封包的帧。

上一节我们了解到，数据包如何走进桥，这一节我们简单看看，入口帧处理函数br_handle_frame_finish.

  作用：br_handle_frame_finish函数主要是决策将不同类别的数据包做不同的分发路径。

其函数处理的过程如下图所示：

首先判断该数据包是否符合桥转发的条件：
(1)桥端口状态是否是开启状态，如果没有开启则丢掉数据包
(2)是否允许从该桥上转发，如果不允许，则直接返回0

获得桥转发的条件以后，开始判断数据包的类型：
(1)判断此时桥的标志为允许做哪些事情，学习还是扩展，如果学习的标志位被至位，则更新数据转发表。否则继续向下走
(2)根据多播或者广播报文的类型决定数据包的去留
(3)判断此时端口的状态，如果是学习状态，则将数据包丢弃
(要注意的是：桥的端口状态(和上面的flag不冲突，上面的flag表示网桥可以做的事情)state表示网桥端口所处于的状态)

在处理完一些需要预备的事情之后，就要为数据包的转发开始做准备了
(1)网桥设备是否处于混杂模式，如果是则建立副本，为发往本地做个备份
 (注意的是，所有网桥端口绑定的设备都会处于混杂模式，因为 网桥运行必须此模式。但除非明确的对其进行配置，否则网桥自己是不会处于混杂模式的)
(2)在次判断广播还是多播地址
广播地址：仅仅设置副本，进行广播转发和发往本地
多播地址：先查多播地址转发表，如果存在，设置副本，进行多播转发，原始数据包指向NULL,如果已经传送至本地，则会释放副本，不进行本地转发，否则重新转发到本地
(3)不是广播或者多播
  判断是否本地地址，如果是本地地址，则将原始数据包指向NULL，发往本地。否则进行数据包转发 

[cpp] view plain copy

1. /* note: already called with rcu_read_lock */  
2. int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb)  
3. {  
4.     const unsigned char *dest = eth_hdr(skb)->h_dest;  
5.     struct net_bridge_port *p = br_port_get_rcu(skb->dev);  
6.     struct net_bridge *br;  
7.     struct net_bridge_fdb_entry *dst;  
8.     struct net_bridge_mdb_entry *mdst;  
9.     struct sk_buff *skb2;  
10.     bool unicast = true;  
11.     u16 vid = 0;  
12.   
13.     if (!p || p->state == BR_STATE_DISABLED)  
14.         goto drop;  
15.     /*判断是否允许进入桥内，如果没有开启vlan则所有的数据包都可以进入， 
16.       如果开启了vlan则根据vlan相应的规则,从桥上进行数据包转发*/  
17.     if (!br_allowed_ingress(p->br, nbp_vlan_group_rcu(p), skb, &vid))  
18.         goto out;  
19.   
20.     /* insert into forwarding database after filtering to avoid spoofing */  
21.     br = p->br;  
22.     /*如果可以学习，则学习数据包的原地址*/  
23.     if (p->flags & BR_LEARNING)  
24.         br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false);  
25.   
26.     if (!is_broadcast_ether_addr(dest) && is_multicast_ether_addr(dest) &&  
27.         br_multicast_rcv(br, p, skb, vid))  
28.         goto drop;  
29.     /*桥的端口状态(和上面的flag不冲突，上面的flag表示网桥可以做的事情) 
30.       state表示网桥端口所处于的状态*/  
31.     if (p->state == BR_STATE_LEARNING)  
32.         goto drop;  
33.   
34.     BR_INPUT_SKB_CB(skb)->brdev = br->dev;  
35.   
36.     /* The packet skb2 goes to the local host (NULL to skip). */  
37.     skb2 = NULL;  
38.   
39.     if (br->dev->flags & IFF_PROMISC)  
40.         skb2 = skb;  
41.   
42.     dst = NULL;  
43.   
44.     if (IS_ENABLED(CONFIG_INET) && skb->protocol == htons(ETH_P_ARP))  
45.         br_do_proxy_arp(skb, br, vid, p);  
46.   
47.     if (is_broadcast_ether_addr(dest)) {  
48.         skb2 = skb;  
49.         unicast = false;  
50.     } else if (is_multicast_ether_addr(dest)) {  
51.         mdst = br_mdb_get(br, skb, vid);  
52.         if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&  
53.             br_multicast_querier_exists(br, eth_hdr(skb))) {  
54.             if ((mdst && mdst->mglist) ||  
55.                 br_multicast_is_router(br))  
56.                 skb2 = skb;  
57.             br_multicast_forward(mdst, skb, skb2);  
58.             skb = NULL;  
59.             if (!skb2)  
60.                 goto out;  
61.         } else  
62.             skb2 = skb;  
63.   
64.         unicast = false;  
65.         br->dev->stats.multicast++;  
66.     } else if ((dst = __br_fdb_get(br, dest, vid)) &&  
67.             dst->is_local) {  
68.         skb2 = skb;  
69.         /* Do not forward the packet since it's local. */  
70.         skb = NULL;  
71.     }  
72.   
73.     if (skb) {  
74.         if (dst) {  
75.             dst->used = jiffies;  
76.             br_forward(dst->dst, skb, skb2);  
77.         } else  
78.             br_flood_forward(br, skb, skb2, unicast);/*扩撒帧*/  
79.     }  
80.     /*将副本传入本地*/  
81.     if (skb2)  
82.         return br_pass_frame_up(skb2);  
83.   
84. out:  
85.     return 0;  
86. drop:  
87.     kfree_skb(skb);  
88.     goto out;  
89. }  

 数据包发送有两个地方，一个是转发出去br_forward或者br_flood_forward，一个是发往本地br_pass_frame_up

二、数据包的转发

    无论是在发往本地还是转发，有一个函数的功能是不能忽略的，就是br_handle_vlan函数

[cpp] view plain copy

1. struct sk_buff *br_handle_vlan(struct net_bridge *br,  
2.                    struct net_bridge_vlan_group *vg,  
3.                    struct sk_buff *skb)  
4. {  
5.     struct br_vlan_stats *stats;  
6.     struct net_bridge_vlan *v;  
7.     u16 vid;  
8.   
9.     /* If this packet was not filtered at input, let it pass */  
10.     if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)  
11.         goto out;  
12.   
13.     /* At this point, we know that the frame was filtered and contains 
14.      * a valid vlan id.  If the vlan id has untagged flag set, 
15.      * send untagged; otherwise, send tagged. 
16.      */  
17.     br_vlan_get_tag(skb, &vid);  
18.     /*find vid from vlan group*/  
19.     v = br_vlan_find(vg, vid);  
20.     /* Vlan entry must be configured at this point.  The 
21.      * only exception is the bridge is set in promisc mode and the 
22.      * packet is destined for the bridge device.  In this case 
23.      * pass the packet as is. 
24.      */  
25.     if (!v || !br_vlan_should_use(v)) {  
26.         if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) {  
27.             goto out;  
28.         } else {  
29.             kfree_skb(skb);  
30.             return NULL;  
31.         }  
32.     }  
33.     /*statistacs the vlan if flow and if the vlan_stats_enabled is true */  
34.     if (br->vlan_stats_enabled) {  
35.         stats = this_cpu_ptr(v->stats);  
36.         u64_stats_update_begin(&stats->syncp);  
37.         stats->tx_bytes += skb->len;  
38.         stats->tx_packets++;  
39.         u64_stats_update_end(&stats->syncp);  
40.     }  
41.   
42.     if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)  
43.         skb->vlan_tci = 0;  
44. out:  
45.     return skb;  
46. }  

这个函数的作用很简单就是，数据包是否要带tag,过程：
在传递进来的vlan group中查找自己所处的vlan
如果该vlan不存在则判断当前模式是否是混杂模式和数据包的设备是否是桥下的设备，选择发包或者丢弃。
如果存在，且vlan是开启的，则统计vlan接口上的数据流量，最后根据vlan出口的标记位进行位运算判断是否要带tag.

然后我们来看一下上节提到的发往本地数据包的处理函数

[cpp] view plain copy

1. static int br_pass_frame_up(struct sk_buff *skb)  
2. {  
3.     struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;  
4.     struct net_bridge *br = netdev_priv(brdev);  
5.     struct net_bridge_vlan_group *vg;  
6.     struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);  
7.     /*统计该桥上的流量*/  
8.     u64_stats_update_begin(&brstats->syncp);  
9.     brstats->rx_packets++;  
10.     brstats->rx_bytes += skb->len;  
11.     u64_stats_update_end(&brstats->syncp);  
12.   
13.     /*获取该桥上的vlan组*/  
14.     vg = br_vlan_group_rcu(br);  
15.     /* Bridge is just like any other port.  Make sure the 
16.      * packet is allowed except in promisc modue when someone 
17.      * may be running packet capture. 
18.      */  
19.     if (!(brdev->flags & IFF_PROMISC) &&  
20.         !br_allowed_egress(vg, skb)) {  
21.         kfree_skb(skb);  
22.         return NET_RX_DROP;  
23.     }  
24.     /*替换掉数据包中的设备信息改为桥设备*/  
25.     indev = skb->dev;  
26.     skb->dev = brdev;  
27.     /*配置数据包vlan的相关信息*/  
28.     skb = br_handle_vlan(br, vg, skb);  
29.     if (!skb)  
30.         return NET_RX_DROP;  
31.     /*进入NF_BR_LOCAL_IN*/  
32.     return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN,  
33.                dev_net(indev), NULL, skb, indev, NULL,  
34.                br_netif_receive_skb);  
35. }  

这个函数所做的事情很简单，就是配置vlan的相关信息后，然后发往本地的netfilter钩子函数中
最后重新回到netif_recive_skb.如下函数：

[cpp] view plain copy

1. static int  
2. br_netif_receive_skb(struct net *net, struct sock *sk, struct sk_buff *skb)  
3. {  
4. <span>  </span>return netif_receive_skb(skb);  
5. }  

再来看看数据包转发的函数

[cpp] view plain copy

1. static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)  
2. {  
3.     struct net_bridge_vlan_group *vg;  
4.     struct net_device *indev;  
5.   
6.     if (skb_warn_if_lro(skb)) {  
7.         kfree_skb(skb);  
8.         return;  
9.     }  
10.     /*获取vlan组，这个组中有许多的vlanid，br_handle_vlan函数就是要在这个组中查找自己的vid*/  
11.     vg = nbp_vlan_group_rcu(to);  
12.     /*添加vlan的相关配置*/  
13.     skb = br_handle_vlan(to->br, vg, skb);  
14.     if (!skb)  
15.         return;  
16.   
17.     indev = skb->dev;  
18.     skb->dev = to->dev;  
19.     skb_forward_csum(skb);  
20.       
21.     NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD,  
22.         dev_net(indev), NULL, skb, indev, skb->dev,  
23.         br_forward_finish);  
24. }  
25.   
26. int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)  
27. {  
28.     return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING,  
29.                net, sk, skb, NULL, skb->dev,  
30.                br_dev_queue_push_xmit);  
31.   
32. }  

整个数据包转发的过程与转发到本地的过程类似，只不过所进入的netfilter钩子点不同.

整个分析中不包含数据包从本地发出的数据包