Home > Developer > Linux

Linux 3.10 kernel bridge forwarding Logic

Source: Internet
Author: User
Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞

Linux 3.10 kernel bridge forwarding Logic
Linux 3.10 kernel bridge forwarding logic-lvyilong316

I have previously analyzed the bridge forwarding logic of linux kernel 2.6.32. Next I will analyze the bridge forwarding logic of linux kernel 3.10. This is exactly the kernel corresponding to CentOS 5 and CentOS 7. 3.10 The greatest change in the bridge logic in the kernel is the addition of vlan processing logic and brdige entry function settings.

1. netdev_rx_handler_register

Before analysis, we should first introduce an important function: netdev_rx_handler_register, which is not available in the 2.6 kernel.

Lnetdev_rx_handler_register


 
 
    
  
  
  1. /*
    2. 
  
  
  2. * Dev: register the dev of the receiving function.
    3. 
  
  
  3. * Rx_handler: The receiving function to be registered
    4. 
  
  
  4. * Rx_handler_data: indicates the data used by rx_handler_data.
    5. 
  
  
  5. */
    6. 
  
  
  6. Int netdev_rx_handler_register (struct net_device * dev,
    7. 
  
  
  7. Rx_handler_func_t * rx_handler,
    8. 
  
  
  8. Void * rx_handler_data)
    9. 
  
  
  9. {
    10. 
  
  
  10. ASSERT_RTNL ();
    11. 
  
  

    12. 
  
  
  12. If (dev-> rx_handler)
    13. 
  
  
  13. Return-EBUSY;
    14. 
  
  

    15. 
  
  
  15. /* Note: rx_handler_data must be set before rx_handler */
    16. 
  
  
  16. Rcu_assign_pointer (dev-> rx_handler_data, rx_handler_data );
    17. 
  
  
  17. Rcu_assign_pointer (dev-> rx_handler, rx_handler );
    18. 
  
  

    19. 
  
  
  19. Return 0;
    20. 
  
  
  20. }
    21.


This function registers the receiving function for the device (net_device), and then calls the registered receiving function based on the device interface that receives the skb In the _ netif_receive_skb function. For example, register the br_handle_frame function for the interface under the bridge, and register the bond_handle_frame function for the bonding interface. This is more flexible than the old-fashioned bridge processing. With this mechanism, you can also register processing functions in the module. For example, openvswitch in 3.10 (OpenvSwitch has already been integrated into the kernel in 3.10) creates the netdev_create function of netdev vport.

Lnetdev_create


 
 
    
  
  
  1. static struct vport *netdev_create(const struct vport_parms *parms)
    2. 
  
  
  2. {
    3. 
  
  
  3.  struct vport *vport;
    4. 
  
  
  4. /....../
    5. 
  
  
  5.  err = netdev_rx_handler_register(netdev_vport->dev, netdev_frame_hook,vport);
    6. 
  
  
  6. /....../
    7. 
  
  
  7. }
    8.


This function sets the reception function of the device as the netdev_frame_hook function when creating the netdev vport, which is also the entry function of the entire openvswitch, if you check the OpenvSwitch source code, you can see that when installed in the 2.6 kernel, The br_handle_frame_hook function of bridge is replaced here, and the bridge logic enters the OpenvSwitch logic.

2. Bridge forwarding Logic Analysis

Analyze the netif_receive_skb function first. This function is the entry to the protocol stack.

Lnetif_receive_skb


 
 
    
  
  
  1. Int netif_receive_skb (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Int ret;
    4. 
  
  
  4. If (skb_defer_rx_timestamp (skb ))
    5. 
  
  
  5. Return NET_RX_SUCCESS;
    6. 
  
  
  6. Rcu_read_lock ();
    7. 
  
  
  7. /* RPS logic processing. Now the RPS mechanism is used in the kernel to distribute packets to the receiving queues of various CPUs for load balancing */
    8. 
  
  
  8. # Ifdef CONFIG_RPS
    9. 
  
  
  9. If (static_key_false (& rps_needed )){
    10. 
  
  
  10. Struct rps_dev_flow voidflow, * rflow = & voidflow;
    11. 
  
  
  11. Int cpu = get_rps_cpu (skb-> dev, skb, & rflow );
    12. 
  
  
  12. If (cpu> = 0 ){
    13. 
  
  
  13. Ret = enqueue_to_backlog (skb, cpu, & rflow-> last_qtail );
    14. 
  
  
  14. Rcu_read_unlock ();
    15. 
  
  
  15. Return ret;
    16. 
  
  
  16. }
    17. 
  
  
  17. }
    18. 
  
  
  18. # Endif
    19. 
  
  
  19. Ret = _ netif_receive_skb (skb );
    20. 
  
  
  20. Rcu_read_unlock ();
    21. 
  
  
  21. Return ret;
    22. 
  
  
  22. }
    23.


Netif_receive_skb only processes the data packet RPS and then calls _ netif_receive_skb.

_ Netif_receive_skb does not have any additional processing logic. It mainly calls _ netif_receive_skb_core, which is actually equivalent to netif_receive_skb of the 2.6 kernel. The following code omits the logic unrelated to bridge.

L _ netif_receive_skb_core


 
 
    
  
  
  1. Static int _ netif_receive_skb_core (struct sk_buff * skb, bool pfmemalloc)
    2. 
  
  
  2. {
    3. 
  
  
  3. Struct packet_type * ptype, * pt_prev;
    4. 
  
  
  4. Rx_handler_func_t * rx_handler;
    5. 
  
  
  5. Struct net_device * orig_dev;
    6. 
  
  
  6. Struct net_device * null_or_dev;
    7. 
  
  
  7. Bool deliver_exact = false;
    8. 
  
  
  8. Int ret = NET_RX_DROP;
    9. 
  
  
  9. _ Be16 type;
    10. 
  
  
  10. /*......*/
    11. 
  
  
  11. Orig_dev = skb-> dev;
    12. 
  
  
  12. Skb_reset_network_header (skb );
    13. 
  
  
  13. Pt_prev = NULL;
    14. 
  
  
  14. Skb-> skb_iif = skb-> dev-> ifindex;
    15. 
  
  
  15. /* Ptype_all protocol processing, tcpdump packet capture here */
    16. 
  
  
  16. List_for_each_entry_rcu (ptype, & ptype_all, list ){
    17. 
  
  
  17. If (! Ptype-> dev | ptype-> dev = skb-> dev ){
    18. 
  
  
  18. If (pt_prev)
    19. 
  
  
  19. Ret = deliver_skb (skb, pt_prev, orig_dev );
    20. 
  
  
  20. Pt_prev = ptype;
    21. 
  
  
  21. }
    22. 
  
  
  22. }
    23. 
  
  
  23. /* Call the rx_handler of the receiving device */
    24. 
  
  
  24. Rx_handler = rcu_dereference (skb-> dev-> rx_handler );
    25. 
  
  
  25. If (rx_handler ){
    26. 
  
  
  26. If (pt_prev ){
    27. 
  
  
  27. Ret = deliver_skb (skb, pt_prev, orig_dev );
    28. 
  
  
  28. Pt_prev = NULL;
    29. 
  
  
  29. }
    30. 
  
  
  30. Switch (rx_handler (& skb )){
    31. 
  
  
  31. Case RX_HANDLER_CONSUMED:
    32. 
  
  
  32. Ret = NET_RX_SUCCESS;
    33. 
  
  
  33. Goto out;
    34. 
  
  
  34. Case RX_HANDLER_ANOTHER:
    35. 
  
  
  35. Goto another_round;
    36. 
  
  
  36. Case RX_HANDLER_EXACT:
    37. 
  
  
  37. Deliver_exact = true;
    38. 
  
  
  38. Case RX_HANDLER_PASS:
    39. 
  
  
  39. Break;
    40. 
  
  
  40. Default:
    41. 
  
  
  41. BUG ();
    42. 
  
  
  42. }
    43. 
  
  
  43. }
    44. 
  
  
  44. /* Pass to the upper-layer protocol according to skb-> protocol */
    45. 
  
  
  45. Type = skb-> protocol;
    46. 
  
  
  46. List_for_each_entry_rcu (ptype, & ptype_base [ntohs (type) & PTYPE_HASH_MASK], list ){
    47. 
  
  
  47. If (ptype-> type = type & (ptype-> dev = null_or_dev | ptype-> dev = skb-> dev | ptype-> dev = orig_dev )) {
    48. 
  
  
  48. If (pt_prev)
    49. 
  
  
  49. Ret = deliver_skb (skb, pt_prev, orig_dev );
    50. 
  
  
  50. Pt_prev = ptype;
    51. 
  
  
  51. }
    52. 
  
  
  52. }
    53. 
  
  
  53. If (pt_prev ){
    54. 
  
  
  54. If (unlikely (skb_orphan_frags (skb, GFP_ATOMIC )))
    55. 
  
  
  55. Goto drop;
    56. 
  
  
  56. Else
    57. 
  
  
  57. Ret = pt_prev-> func (skb, skb-> dev, pt_prev, orig_dev );
    58. 
  
  
  58. } Else {
    59. 
  
  
  59. Drop:
    60. 
  
  
  60. Atomic_long_inc (& skb-> dev-> rx_dropped );
    61. 
  
  
  61. Kfree_skb (skb );
    62. 
  
  
  62. Ret = NET_RX_DROP;
    63. 
  
  
  63. }
    64. 
  
  
  64. Out:
    65. 
  
  
  65. Return ret;
    66. 
  
  
  66. }
    67.


If a dev is added to a bridge (as an interface of the bridge), The rx_handler of this interface device is set to the br_handle_frame function, which is set in the br_add_if function, br_add_if (net/bridge/br_if.c) is set when an interface is added to the bridge device. Entering br_handle_frame also enters the bridge logic code.

Lbr_add_if


 
 
    
  
  
  1. int br_add_if(struct net_bridge *br, struct net_device *dev)
    2. 
  
  
  2. {
    3. 
  
  
  3.  /*......*/
    4. 
  
  
  4.  err = netdev_rx_handler_register(dev, br_handle_frame, p);
    5. 
  
  
  5.  /*......*/
    6. 
  
  
  6. }
    7.


Lbr_handle_frame


 
 
    
  
  
  1. Rx_handler_result_t br_handle_frame (struct sk_buff ** pskb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Struct net_bridge_port * p;
    4. 
  
  
  4. Struct sk_buff * skb = * pskb;
    5. 
  
  
  5. Const unsigned char * dest = eth_hdr (skb)-> h_dest;
    6. 
  
  
  6. Br_should_route_hook_t * fig;
    7. 
  
  
  7. If (unlikely (skb-> pkt_type = PACKET_LOOPBACK ))
    8. 
  
  
  8. Return RX_HANDLER_PASS;
    9. 
  
  
  9. If (! Is_valid_ether_addr (eth_hdr (skb)-> h_source ))
    10. 
  
  
  10. Goto drop;
    11. 
  
  
  11. Skb = skb_share_check (skb, GFP_ATOMIC );
    12. 
  
  
  12. If (! Skb)
    13. 
  
  
  13. Return RX_HANDLER_CONSUMED;
    14. 
  
  
  14. /* Get the bridge port corresponding to dev */
    15. 
  
  
  15. P = br_port_get_rcu (skb-> dev );
    16. 
  
  
  16. /* Special target mac address processing */
    17. 
  
  
  17. If (unlikely (is_link_local_ether_addr (dest ))){
    18. 
  
  
  18. /*
    19. 
  
  
  19. * See IEEE 802.1D Table 7-10 Reserved addresses
    20. 
  
  
  20. *
    21. 
  
  
  21. * Assignment Value
    22. 
  
  
  22. * Bridge Group Address 01-80-C2-00-00-00
    23. 
  
  
  23. * (MAC Control) 802.3 01-80-C2-00-00-01
    24. 
  
  
  24. * (Link Aggregation) 802.3 01-80-C2-00-00-02
    25. 
  
  
  25. * 802.1X PAE address 01-80-C2-00-00-03
    26. 
  
  
  26. *
    27. 
  
  
  27. * 802.1AB LLDP 01-80-C2-00-00-0E
    28. 
  
  
  28. *
    29. 
  
  
  29. * Others reserved for future standardization
    30. 
  
  
  30. */
    31. 
  
  
  31. Switch (dest [5]) {
    32. 
  
  
  32. Case 0x00:/* Bridge Group Address */
    33. 
  
  
  33. /* If STP is turned off, then must forward to keep loop detection */
    34. 
  
  
  34. If (p-> br-> stp_enabled = BR_NO_STP)
    35. 
  
  
  35. Goto forward;
    36. 
  
  
  36. Break;
    37. 
  
  
  37. Case 0x01:/* ieee mac (Pause )*/
    38. 
  
  
  38. Goto drop;
    39. 
  
  
  39. Default:
    40. 
  
  
  40. /* Allow selective forwarding for most other protocols */
    41. 
  
  
  41. If (p-> br-> group_fwd_mask & (1u <dest [5])
    42. 
  
  
  42. Goto forward;
    43. 
  
  
  43. }
    44. 
  
  
  44. /* LOCAL_IN hook Point, note that after this hook point does not mean to be sent to the host protocol stack (only the special purpose mac01-80-C2 will come here )*/
    45. 
  
  
  45. If (NF_HOOK (NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb-> dev,
    46. 
  
  
  46. NULL, br_handle_local_finish )){
    47. 
  
  
  47. Return RX_HANDLER_CONSUMED;/* consumed by filter */
    48. 
  
  
  48. } Else {
    49. 
  
  
  49. * Pskb = skb;
    50. 
  
  
  50. Return RX_HANDLER_PASS;/* continue processing */
    51. 
  
  
  51. }
    52. 
  
  
  52. }
    53. 
  
  
  53. /* Forwarding logic */
    54. 
  
  
  54. Forward:
    55. 
  
  
  55. Switch (p-> state ){
    56. 
  
  
  56. Case BR_STATE_FORWARDING:
    57. 
  
  
  57. Fig = rcu_dereference (br_should_route_hook );
    58. 
  
  
  58. If (FIG ){
    59. 
  
  
  59. If (* fig) (skb )){
    60. 
  
  
  60. * Pskb = skb;
    61. 
  
  
  61. Return RX_HANDLER_PASS;
    62. 
  
  
  62. }
    63. 
  
  
  63. Dest = eth_hdr (skb)-> h_dest;
    64. 
  
  
  64. }
    65. 
  
  
  65. /* Fall through */
    66. 
  
  
  66. Case BR_STATE_LEARNING:
    67. 
  
  
  67. /* If the target mac of the skb is the same as that of the mac of the bridge, the skb is sent to the local protocol stack */
    68. 
  
  
  68. If (ether_addr_equal (p-> br-> dev-> dev_addr, dest ))
    69. 
  
  
  69. Skb-> pkt_type = PACKET_HOST;
    70. 
  
  
  70. /* NF_BR_PRE_ROUTING hook Point */
    71. 
  
  
  71. NF_HOOK (NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb-> dev, NULL, br_handle_frame_finish );
    72. 
  
  
  72. Break;
    73. 
  
  
  73. Default:
    74. 
  
  
  74. Drop:
    75. 
  
  
  75. Kfree_skb (skb );
    76. 
  
  
  76. }
    77. 
  
  
  77. Return RX_HANDLER_CONSUMED;
    78. 
  
  
  78. }
    79.


After the NF_BR_LOCAL_IN hook point, the br_handle_local_finish function is executed.

Lbr_handle_local_finish


 
 
    
  
  
  1. Static int br_handle_local_finish (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Struct net_bridge_port * p = br_port_get_rcu (skb-> dev );
    4. 
  
  
  4. 2010vid = 0;
    5. 
  
  
  5. /* Obtain the skb vlan id (3.10 of the bridge Support vlan )*/
    6. 
  
  
  6. Br_vlan_get_tag (skb, & vid );
    7. 
  
  
  7. /* Update the mac table of bridge. Note that the vlan id is also a parameter, indicating that each vlan has an independent mac table */
    8. 
  
  
  8. Br_fdb_update (p-> br, p, eth_hdr (skb)-> h_source, vid );
    9. 
  
  
  9. Return 0;/* process further */
    10. 
  
  
  10. }
    11.


The br_handle_frame_finish function is executed after the NF_BR_PRE_ROUTING hook Point.

Lbr_handle_frame_finish


 
 
    
  
  
  1. Int br_handle_frame_finish (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Const unsigned char * dest = eth_hdr (skb)-> h_dest;
    4. 
  
  
  4. Struct net_bridge_port * p = br_port_get_rcu (skb-> dev );
    5. 
  
  
  5. Struct net_bridge * br;
    6. 
  
  
  6. Struct net_bridge_fdb_entry * dst;
    7. 
  
  
  7. Struct net_bridge_mdb_entry * mdst;
    8. 
  
  
  8. Struct sk_buff * skb2;
    9. 
  
  
  9. 2010vid = 0;
    10. 
  
  
  10. If (! P | p-> state = BR_STATE_DISABLED)
    11. 
  
  
  11. Goto drop;
    12. 
  
  
  12. /* This check mainly involves vlan-related checks, for example, whether the vlan is the same as the vlan configured for the receiving interface */
    13. 
  
  
  13. If (! Br_allowed_ingress (p-> br, nbp_get_vlan_info (p), skb, & vid ))
    14. 
  
  
  14. Goto out;
    15. 
  
  
  15. /* Insert into forwarding database after filtering to avoid spoofing */
    16. 
  
  
  16. Br = p-> br;
    17. 
  
  
  17. /* Update the forwarding database */
    18. 
  
  
  18. Br_fdb_update (br, p, eth_hdr (skb)-> h_source, vid );
    19. 
  
  
  19. /* Multicast mac Processing */
    20. 
  
  
  20. If (! Is_broadcast_ether_addr (dest) & is_multicast_ether_addr (dest )&&
    21. 
  
  
  21. Br_multicast_rcv (br, p, skb ))
    22. 
  
  
  22. Goto drop;
    23. 
  
  
  23. If (p-> state = BR_STATE_LEARNING)
    24. 
  
  
  24. Goto drop;
    25. 
  
  
  25. BR_INPUT_SKB_CB (skb)-> brdev = br-> dev;
    26. 
  
  
  26. /* The packet skb2 goes to the local host (NULL to skip ).*/
    27. 
  
  
  27. Skb2 = NULL;
    28. 
  
  
  28. /* If the bridge is set to the hybrid mode */
    29. 
  
  
  29. If (br-> dev-> flags & IFF_PROMISC)
    30. 
  
  
  30. Skb2 = skb;
    31. 
  
  
  31. Dst = NULL;
    32. 
  
  
  32. /* If the target mac of skb is broadcast */
    33. 
  
  
  33. If (is_broadcast_ether_addr (dest ))
    34. 
  
  
  34. Skb2 = skb;
    35. 
  
  
  35. Else if (is_multicast_ether_addr (dest) {/* multicast */
    36. 
  
  
  36. Mdst = br_mdb_get (br, skb, vid );
    37. 
  
  
  37. If (mdst | BR_INPUT_SKB_CB_MROUTERS_ONLY (skb )){
    38. 
  
  
  38. If (mdst & mdst-> mglist) |
    39. 
  
  
  39. Br_multicast_is_router (br ))
    40. 
  
  
  40. Skb2 = skb;
    41. 
  
  
  41. Br_multicast_forward (mdst, skb, skb2 );
    42. 
  
  
  42. Skb = NULL;
    43. 
  
  
  43. If (! Skb2)
    44. 
  
  
  44. Goto out;
    45. 
  
  
  45. } Else
    46. 
  
  
  46. Skb2 = skb;
    47. 
  
  
  47. Br-> dev-> stats. multicast ++;
    48. 
  
  
  48. } Else if (dst = _ br_fdb_get (br, dest, vid) & dst-> is_local) {/* the destination address is the mac address of the local machine, then it is sent to the local protocol stack */
    49. 
  
  
  49. Skb2 = skb;
    50. 
  
  
  50. /* Do not forward the packet since it's local .*/
    51. 
  
  
  51. Skb = NULL;
    52. 
  
  
  52. }
    53. 
  
  
  53. If (skb ){
    54. 
  
  
  54. If (dst ){
    55. 
  
  
  55. Dst-> used = jiffies;
    56. 
  
  
  56. Br_forward (dst-> dst, skb, skb2); // forward it to the Target Interface
    57. 
  
  
  57. } Else
    58. 
  
  
  58. Br_flood_forward (br, skb, skb2); // broadcast if the target interface is not found
    59. 
  
  
  59. }
    60. 
  
  
  60. If (skb2)
    61. 
  
  
  61. Return br_pass_frame_up (skb2); // send it to the local protocol stack
    62. 
  
  
  62. Out:
    63. 
  
  
  63. Return 0;
    64. 
  
  
  64. Drop:
    65. 
  
  
  65. Kfree_skb (skb );
    66. 
  
  
  66. Goto out;
    67. 
  
  
  67. }
    68.


Let's first look at the br_pass_frame_up function sent to the local protocol stack.

Lbr_pass_frame_up

 
 
    
  
  
  1. Static int br_pass_frame_up (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Struct net_device * indev, * brdev = BR_INPUT_SKB_CB (skb)-> brdev;
    4. 
  
  
  4. Struct net_bridge * br = netdev_priv (brdev );
    5. 
  
  
  5. // Update the statistics (omitted)
    6. 
  
  
  6. /* Bridge is just like any other port. Make sure
    7. 
  
  
  7. * Packet is allowed within T in promisc modue when someone
    8. 
  
  
  8. * May be running packet capture.
    9. 
  
  
  9. */
    10. 
  
  
  10. If (! (Brdev-> flags & IFF_PROMISC )&&! Br_allowed_egress (br, br_get_vlan_info (br), skb )){
    11. 
  
  
  11. Kfree_skb (skb); // if it is not in hybrid mode and the vlan processing is not required, it is discarded.
    12. 
  
  
  12. Return NET_RX_DROP;
    13. 
  
  
  13. }
    14. 
  
  
  14. // Vlan processing logic
    15. 
  
  
  15. Skb = br_handle_vlan (br, br_get_vlan_info (br), skb );
    16. 
  
  
  16. If (! Skb)
    17. 
  
  
  17. Return NET_RX_DROP;
    18. 
  
  
  18. Indev = skb-> dev;
    19. 
  
  
  19. Skb-> dev = brdev; // key point. Here, skb-> dev is changed to bridge.
    20. 
  
  
  20. // Go to the protocol stack again after NF_BR_LOCAL_IN
    21. 
  
  
  21. Return NF_HOOK (NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, indev, NULL,
    22. 
  
  
  22. Netif_receive_skb );
    23. 
  
  
  23. }
    24.

Enter netif_receive_skb again, because skb-dev is set to bridge, and the rx_handler function of the bridge device is not set, so it will not enter the bridge logic again, directly enters the upper-layer protocol stack of the host.

The forwarding logic is mainly used in the br_forward function, while br_forward mainly calls the _ br_forward function.

L _ br_forward


 
 
    
  
  
  1. Static void _ br_forward (const struct net_bridge_port * to, struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. Struct net_device * indev;
    4. 
  
  
  4. // Vlan Processing
    5. 
  
  
  5. Skb = br_handle_vlan (to-> br, nbp_get_vlan_info (to), skb );
    6. 
  
  
  6. If (! Skb)
    7. 
  
  
  7. Return;
    8. 
  
  
  8. Indev = skb-> dev;
    9. 
  
  
  9. Skb-> dev = to-> dev; // skb-> dev is set as the exit device dev
    10. 
  
  
  10. Skb_forward_csum (skb );
    11. 
  
  
  11. // Call br_forward_finish after the NF_BR_FORWARD hook Point
    12. 
  
  
  12. NF_HOOK (NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb-> dev,
    13. 
  
  
  13. Br_forward_finish );
    14. 
  
  
  14. }
    15.

Lbr_forward_finish

 
 
    
  
  
  1. Int br_forward_finish (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. // Call br_dev_queue_push_xmit after the NF_BR_POST_ROUTING hook Point
    4. 
  
  
  4. Return NF_HOOK (NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb-> dev, br_dev_queue_push_xmit );
    5. 
  
  
  5. }
    6.

Lbr_dev_queue_push_xmit

 
 
    
  
  
  1. Int br_dev_queue_push_xmit (struct sk_buff * skb)
    2. 
  
  
  2. {
    3. 
  
  
  3. /* Ip_fragment doesn't copy the MAC header */
    4. 
  
  
  4. If (nf_bridge_maybe_copy_header (skb) | (packet_length (skb)> skb-> dev-> mtu &&! Skb_is_gso (skb ))){
    5. 
  
  
  5. Kfree_skb (skb );
    6. 
  
  
  6. } Else {
    7. 
  
  
  7. Skb_push (skb, ETH_HLEN );
    8. 
  
  
  8. Br_drop_fake_rtable (skb );
    9. 
  
  
  9. Dev_queue_xmit (skb); // send it to the Link Layer
    10. 
  
  
  10. }
    11. 
  
  
  11. Return 0;
    12. 
  
  
  12. }
    13.

When Skb enters dev_queue_xmit, it calls the sending function of the corresponding device driver. That is, the bridge logic. As a result, the bridge forwarding logic of 3.10kernel is shown in:

Note: Like 2.6kernel, bridge OUTPUT hook points are in the send function of bridge dev, which is not analyzed and listed here.

This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

Get Started for Free

  • Sales Support

    1 on 1 presale consultation

    Chat Contact Sales

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

    Open a Ticket

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

    Learn More