Linux 网络协议栈开发（六）—— 二层桥转发蓝图（下）

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

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

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

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

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

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

 /* note: already called with rcu_read_lock */
 int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
     const unsigned char *dest = eth_hdr(skb)->h_dest;
     struct net_bridge_port *p = br_port_get_rcu(skb->dev);
     struct net_bridge *br;
     struct net_bridge_fdb_entry *dst;
     struct net_bridge_mdb_entry *mdst;
     struct sk_buff *skb2;
     bool unicast = true;
     u16 vid = 0;

     if (!p || p->state == BR_STATE_DISABLED)
         goto drop;
     /*判断是否允许进入桥内，如果没有开启vlan则所有的数据包都可以进入，
       如果开启了vlan则根据vlan相应的规则,从桥上进行数据包转发*/
     if (!br_allowed_ingress(p->br, nbp_vlan_group_rcu(p), skb, &vid))
         goto out;

     /* insert into forwarding database after filtering to avoid spoofing */
     br = p->br;
     /*如果可以学习，则学习数据包的原地址*/
     if (p->flags & BR_LEARNING)
         br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false);

     if (!is_broadcast_ether_addr(dest) && is_multicast_ether_addr(dest) &&
         br_multicast_rcv(br, p, skb, vid))
         goto drop;
     /*桥的端口状态(和上面的flag不冲突，上面的flag表示网桥可以做的事情)
       state表示网桥端口所处于的状态*/
     if (p->state == BR_STATE_LEARNING)
         goto drop;

     BR_INPUT_SKB_CB(skb)->brdev = br->dev;

     /* The packet skb2 goes to the local host (NULL to skip). */
     skb2 = NULL;

     if (br->dev->flags & IFF_PROMISC)
         skb2 = skb;

     dst = NULL;

     if (IS_ENABLED(CONFIG_INET) && skb->protocol == htons(ETH_P_ARP))
         br_do_proxy_arp(skb, br, vid, p);

     if (is_broadcast_ether_addr(dest)) {
         skb2 = skb;
         unicast = false;
     } else if (is_multicast_ether_addr(dest)) {
         mdst = br_mdb_get(br, skb, vid);
         if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
             br_multicast_querier_exists(br, eth_hdr(skb))) {
             if ((mdst && mdst->mglist) ||
                 br_multicast_is_router(br))
                 skb2 = skb;
             br_multicast_forward(mdst, skb, skb2);
             skb = NULL;
             if (!skb2)
                 goto out;
         } else
             skb2 = skb;

         unicast = false;
         br->dev->stats.multicast++;
     } else if ((dst = __br_fdb_get(br, dest, vid)) &&
             dst->is_local) {
         skb2 = skb;
         /* Do not forward the packet since it's local. */
         skb = NULL;
     }

     if (skb) {
         if (dst) {
             dst->used = jiffies;
             br_forward(dst->dst, skb, skb2);
         } else
             br_flood_forward(br, skb, skb2, unicast);/*扩撒帧*/
     }
     /*将副本传入本地*/
     if (skb2)
         return br_pass_frame_up(skb2);

 out:
     return 0;
 drop:
     kfree_skb(skb);
     goto out;
 }

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

二、数据包的转发

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

 struct sk_buff *br_handle_vlan(struct net_bridge *br,
                    struct net_bridge_vlan_group *vg,
                    struct sk_buff *skb)
 {
     struct br_vlan_stats *stats;
     struct net_bridge_vlan *v;
     u16 vid;

     /* If this packet was not filtered at input, let it pass */
     if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
         goto out;

     /* At this point, we know that the frame was filtered and contains
      * a valid vlan id.  If the vlan id has untagged flag set,
      * send untagged; otherwise, send tagged.
      */
     br_vlan_get_tag(skb, &vid);
     /*find vid from vlan group*/
     v = br_vlan_find(vg, vid);
     /* Vlan entry must be configured at this point.  The
      * only exception is the bridge is set in promisc mode and the
      * packet is destined for the bridge device.  In this case
      * pass the packet as is.
      */
     if (!v || !br_vlan_should_use(v)) {
         if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) {
             goto out;
         } else {
             kfree_skb(skb);
             return NULL;
         }
     }
     /*statistacs the vlan if flow and if the vlan_stats_enabled is true */
     if (br->vlan_stats_enabled) {
         stats = this_cpu_ptr(v->stats);
         u64_stats_update_begin(&stats->syncp);
         stats->tx_bytes += skb->len;
         stats->tx_packets++;
         u64_stats_update_end(&stats->syncp);
     }

     if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
         skb->vlan_tci = 0;
 out:
     return skb;
 }

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

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

 static int br_pass_frame_up(struct sk_buff *skb)
 {
     struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;
     struct net_bridge *br = netdev_priv(brdev);
     struct net_bridge_vlan_group *vg;
     struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
     /*统计该桥上的流量*/
     u64_stats_update_begin(&brstats->syncp);
     brstats->rx_packets++;
     brstats->rx_bytes += skb->len;
     u64_stats_update_end(&brstats->syncp);

     /*获取该桥上的vlan组*/
     vg = br_vlan_group_rcu(br);
     /* Bridge is just like any other port.  Make sure the
      * packet is allowed except in promisc modue when someone
      * may be running packet capture.
      */
     if (!(brdev->flags & IFF_PROMISC) &&
         !br_allowed_egress(vg, skb)) {
         kfree_skb(skb);
         return NET_RX_DROP;
     }
     /*替换掉数据包中的设备信息改为桥设备*/
     indev = skb->dev;
     skb->dev = brdev;
     /*配置数据包vlan的相关信息*/
     skb = br_handle_vlan(br, vg, skb);
     if (!skb)
         return NET_RX_DROP;
     /*进入NF_BR_LOCAL_IN*/
     return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN,
                dev_net(indev), NULL, skb, indev, NULL,
                br_netif_receive_skb);
 }

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

 static int
 br_netif_receive_skb(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
   return netif_receive_skb(skb);
 }

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

 static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
 {
     struct net_bridge_vlan_group *vg;
     struct net_device *indev;

     if (skb_warn_if_lro(skb)) {
         kfree_skb(skb);
         return;
     }
     /*获取vlan组，这个组中有许多的vlanid，br_handle_vlan函数就是要在这个组中查找自己的vid*/
     vg = nbp_vlan_group_rcu(to);
     /*添加vlan的相关配置*/
     skb = br_handle_vlan(to->br, vg, skb);
     if (!skb)
         return;

     indev = skb->dev;
     skb->dev = to->dev;
     skb_forward_csum(skb);

     NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD,
         dev_net(indev), NULL, skb, indev, skb->dev,
         br_forward_finish);
 }

 int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 {
     return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING,
                net, sk, skb, NULL, skb->dev,
                br_dev_queue_push_xmit);

 }

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

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