Docker网络基础 - Linux网桥工作原理与实现

系统 Linux
网桥是工作在 TCP/IP 协议栈的第二层,也就是说,网桥能够根据目标 MAC 地址对数据包进行广播或者单播。当目标 MAC 地址能够从网桥的 hash 表中找到对应的网桥端口,说明此数据包是单播的数据包,否则就是广播的数据包。

[[385591]]

本文转载自微信公众号「Linux内核那些事」,作者songsong001 。转载本文请联系Linux内核那些事公众号。

Linux 的 网桥 是一种虚拟设备(使用软件实现),可以将 Linux 内部多个网络接口连接起来,如下图所示:

 

而将网络接口连接起来的结果就是,一个网络接口接收到网络数据包后,会复制到其他网络接口中,如下图所示:

 

如上图所示,当网络接口A接收到数据包后,网桥 会将数据包复制并且发送给连接到 网桥 的其他网络接口(如上图中的网卡B和网卡C)。

Docker 就是使用 网桥 来进行容器间通讯的,我们来看看 Docker 是怎么利用 网桥 来进行容器间通讯的,原理如下图:

 

Docker 在启动时,会创建一个名为 docker0 的 网桥,并且把其 IP 地址设置为 172.17.0.1/16(私有 IP 地址)。然后使用虚拟设备对 veth-pair 来将容器与 网桥 连接起来,如上图所示。而对于 172.17.0.0/16 网段的数据包,Docker 会定义一条 iptables NAT 的规则来将这些数据包的 IP 地址转换成公网 IP 地址,然后通过真实网络接口(如上图的 ens160 接口)发送出去。

接下来,我们主要通过代码来分析 网桥 的实现。

网桥的实现

1. 网桥的创建

我们可以通过下面命令来添加一个名为 br0 的 网桥 设备对象:

  1. [root@vagrant]# brctl addbr br0 

然后,我们可以通过命令 brctl show 来查看系统中所有的 网桥 设备列表,如下:

  1. [root@vagrant]# brctl show 
  2. bridge name     bridge id               STP enabled     interfaces 
  3. br0             8000.000000000000       no 
  4. docker0         8000.000000000000       no 

当使用命令创建一个新的 网桥 设备时,会触发内核调用 br_add_bridge() 函数,其实现如下:

  1. int br_add_bridge(char *name
  2.     struct net_bridge *br; 
  3.  
  4.     if ((br = new_nb(name)) == NULL) // 创建一个网桥设备对象 
  5.         return -ENOMEM; 
  6.  
  7.     if (__dev_get_by_name(name) != NULL) { // 设备名是否已经注册过? 
  8.         kfree(br); 
  9.         return -EEXIST; // 返回错误, 不能重复注册相同名字的设备 
  10.     } 
  11.  
  12.     // 添加到网桥列表中 
  13.     br->next = bridge_list; 
  14.     bridge_list = br; 
  15.     ... 
  16.     register_netdev(&br->dev); // 把网桥注册到网络设备中 
  17.  
  18.     return 0; 

br_add_bridge() 函数主要完成以下几个工作:

  • 调用 new_nb() 函数创建一个 网桥 设备对象。
  • 调用 __dev_get_by_name() 函数检查设备名是否已经被注册过,如果注册过返回错误信息。
  • 将 网桥 设备对象添加到 bridge_list 链表中,内核使用 bridge_list 链表来保存所有 网桥 设备。
  • 调用 register_netdev() 将网桥设备注册到网络设备中。

从上面的代码可知,网桥 设备使用了 net_bridge 结构来描述,其定义如下:

  1. struct net_bridge 
  2.     struct net_bridge           *next;               // 连接内核中所有的网桥对象 
  3.     rwlock_t                    lock;                // 锁 
  4.     struct net_bridge_port      *port_list;          // 网桥端口列表 
  5.     struct net_device           dev;                 // 网桥设备信息 
  6.     struct net_device_stats     statistics;          // 信息统计 
  7.     rwlock_t                    hash_lock;           // 用于锁定CAM表 
  8.     struct net_bridge_fdb_entry *hash[BR_HASH_SIZE]; // CAM表 
  9.     struct timer_list           tick; 
  10.  
  11.     /* STP */ 
  12.     ... 
  13. }; 

在 net_bridge 结构中,比较重要的字段为 port_list 和 hash:

  • port_list:网桥端口列表,保存着绑定到 网桥 的网络接口列表。
  • hash:保存着以网络接口 MAC地址 为键值,以网桥端口为值的哈希表。

网桥端口 使用结构体 net_bridge_port 来描述,其定义如下:

  1. struct net_bridge_port 
  2.     struct net_bridge_port  *next;   // 指向下一个端口 
  3.     struct net_bridge       *br;     // 所属网桥设备对象 
  4.     struct net_device       *dev;    // 网络接口设备对象 
  5.     int                     port_no; // 端口号 
  6.  
  7.     /* STP */ 
  8.     ... 
  9. }; 

而 net_bridge_fdb_entry 结构用于描述网络接口设备 MAC地址 与 网桥端口 的对应关系,其定义如下:

  1. struct net_bridge_fdb_entry 
  2.     struct net_bridge_fdb_entry *next_hash; 
  3.     struct net_bridge_fdb_entry **pprev_hash; 
  4.     atomic_t                    use_count; 
  5.     mac_addr                    addr;  // 网络接口设备MAC地址 
  6.     struct net_bridge_port      *dst;  // 网桥端口 
  7.     ... 
  8. }; 

这三个结构的对应关系如下图所示:

 

可见,要将 网络接口设备 绑定到一个 网桥 上,需要使用 net_bridge_port 结构来关联的,下面我们来分析怎么将一个 网络接口设备 绑定到一个 网桥 中。

网桥是工作在 TCP/IP 协议栈的第二层,也就是说,网桥能够根据目标 MAC 地址对数据包进行广播或者单播。当目标 MAC 地址能够从网桥的 hash 表中找到对应的网桥端口,说明此数据包是单播的数据包,否则就是广播的数据包。

2. 将网络接口绑定到网桥

要将一个 网络接口设备 绑定到一个 网桥 上,可以使用以下命令:

  1. [root@vagrant]# brctl addif br0 eth0 

上面的命令让网络接口 eth0 绑定到网桥 br0 上。

当调用命令将网络接口设备绑定到网桥上时,内核会触发调用 br_add_if() 函数来实现,其代码如下:

  1. int br_add_if(struct net_bridge *br, struct net_device *dev) 
  2.     struct net_bridge_port *p; 
  3.     ... 
  4.     write_lock_bh(&br->lock); 
  5.  
  6.     // 创建一个新的网桥端口对象, 并添加到网桥的port_list链表中 
  7.     if ((p = new_nbp(br, dev)) == NULL) {  
  8.         write_unlock_bh(&br->lock); 
  9.         dev_put(dev); 
  10.         return -EXFULL; 
  11.     } 
  12.  
  13.     // 设置网络接口设备为混杂模式 
  14.     dev_set_promiscuity(dev, 1); 
  15.     ... 
  16.     // 添加到网络接口MAC地址与网桥端口对应的哈希表中 
  17.     br_fdb_insert(br, p, dev->dev_addr, 1); 
  18.     ... 
  19.     write_unlock_bh(&br->lock); 
  20.  
  21.     return 0; 

br_add_if() 函数主要完成以下工作:

  • 调用 new_nbp() 函数创建一个新的 网桥端口 并且添加到 网桥 的 port_list 链表中。
  • 将网络接口设备设置为 混杂模式。
  • 调用 br_fdb_insert() 函数将新建的 网桥端口 插入到网络接口 MAC地址 对应的哈希表中。

也就是说,br_add_if() 函数主要建立 网络接口设备 与 网桥 的关系。

3. 网桥中的网络接口接收数据

当某个 网络接口 接收到数据包时,会判断这个 网络接口 是否绑定到某个 网桥 上,如果绑定了,那么就调用 handle_bridge() 函数处理这个数据包。handle_bridge() 函数实现如下:

  1. static int __inline__ 
  2. handle_bridge(struct sk_buff *skb, struct packet_type *pt_prev) 
  3.     int ret = NET_RX_DROP; 
  4.     ... 
  5.     br_handle_frame_hook(skb); 
  6.     return ret; 

br_handle_frame_hook 是一个函数指针,其指向 br_handle_frame() 函数,我们来分析 br_handle_frame() 函数的实现:

  1. void br_handle_frame(struct sk_buff *skb) 
  2.     struct net_bridge *br; 
  3.  
  4.     br = skb->dev->br_port->br; // 获取设备连接的网桥对象 
  5.  
  6.     read_lock(&br->lock);   // 对网桥上锁 
  7.     __br_handle_frame(skb); // 调用__br_handle_frame()函数处理数据包 
  8.     read_unlock(&br->lock); 

br_handle_frame() 函数的实现比较简单,首先对 网桥 进行上锁操作,然后调用 __br_handle_frame() 处理数据包,我们来分析 __br_handle_frame() 函数的实现:

  1. static void __br_handle_frame(struct sk_buff *skb) 
  2.     struct net_bridge *br; 
  3.     unsigned char *dest; 
  4.     struct net_bridge_fdb_entry *dst; 
  5.     struct net_bridge_port *p; 
  6.     int passedup; 
  7.  
  8.     dest = skb->mac.ethernet->h_dest; // 目标MAC地址 
  9.     p = skb->dev->br_port;            // 网络接口绑定的端口 
  10.     br = p->br; 
  11.     passedup = 0; 
  12.     ... 
  13.     // 将学习到的MAC地址插入到网桥的hash表中 
  14.     if (p->state == BR_STATE_LEARNING || p->state == BR_STATE_FORWARDING) 
  15.         br_fdb_insert(br, p, skb->mac.ethernet->h_source, 0); 
  16.     ... 
  17.     if (dest[0] & 1) {        // 如果是一个广播包 
  18.         br_flood(br, skb, 1); // 把数据包发送给连接到网桥上的所有网络接口 
  19.         if (!passedup) 
  20.             br_pass_frame_up(br, skb); 
  21.         else 
  22.             kfree_skb(skb); 
  23.         return
  24.     } 
  25.  
  26.     dst = br_fdb_get(br, dest);    // 获取目标MAC地址对应的网桥端口 
  27.     ... 
  28.     if (dst != NULL) {             // 如果目标MAC地址对应的网桥端口存在 
  29.         br_forward(dst->dst, skb); // 那么只将数据包转发给此端口 
  30.         br_fdb_put(dst); 
  31.         return
  32.     } 
  33.  
  34.     br_flood(br, skb, 0); // 否则发送给连接到此网桥上的所有网络接口 
  35.     return
  36.     ... 

__br_handle_frame() 函数主要完成以下几个工作:

  • 首先将从数据包中学习到的MAC地址插入到网桥的hash表中。
  • 如果数据包是一个广播包(目标MAC地址的第一位为1),那么调用 br_flood() 函数把数据包发送给连接到网桥上的所有网络接口。
  • 调用 br_fdb_get() 获取目标MAC地址对应的网桥端口,如果目标MAC地址对应的网桥端口存在,那么调用 br_forward() 函数把数据包转发给此端口。
  • 否则调用 调用 br_flood() 函数把数据包发送给连接到网桥上的所有网络接口。

函数 br_forward() 用于把数据包发送给指定的网桥端口,其实现如下:

  1. static void __br_forward(struct net_bridge_port *to, struct sk_buff *skb) 
  2.     skb->dev = to->dev; 
  3.     dev_queue_xmit(skb); 
  4.  
  5. void br_forward(struct net_bridge_port *to, struct sk_buff *skb) 
  6.     if (should_forward(to, skb)) { // 端口是否能够接收数据? 
  7.         __br_forward(to, skb); 
  8.         return
  9.     } 
  10.     kfree_skb(skb); 

br_forward() 函数通过调用 __br_forward() 函数来发送数据给指定的网桥端口,__br_forward() 函数首先将数据包的输出接口设备设置为网桥端口绑定的设备,然后调用 dev_queue_xmit() 函数将数据包发送出去。

而 br_flood() 函数用于将数据包发送给绑定到 网桥 上的所有网络接口设备,其实现如下:

  1. void br_flood(struct net_bridge *br, struct sk_buff *skb, int clone) 
  2.     struct net_bridge_port *p; 
  3.     struct net_bridge_port *prev; 
  4.     ... 
  5.     prev = NULL
  6.  
  7.     p = br->port_list; 
  8.     while (p != NULL) {              // 遍历绑定到网桥的所有网络接口设备 
  9.         if (should_forward(p, skb)) { // 端口是否能够接收数据包? 
  10.             if (prev != NULL) { 
  11.                 struct sk_buff *skb2; 
  12.  
  13.                 // 克隆一个数据包 
  14.                 if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL) {  
  15.                     br->statistics.tx_dropped++; 
  16.                     kfree_skb(skb); 
  17.                     return
  18.                 } 
  19.  
  20.                 __br_forward(prev, skb2); // 把数据包发送给设备 
  21.             } 
  22.  
  23.             prev = p; 
  24.         } 
  25.  
  26.         p = p->next
  27.     } 
  28.  
  29.     if (prev != NULL) { 
  30.         __br_forward(prev, skb); 
  31.         return
  32.     } 
  33.  
  34.     kfree_skb(skb); 

 

br_flood() 函数的实现也比较简单,主要是遍历绑定到网桥的所有网络接口设备,然后调用 __br_forward() 函数将数据包转发给设备对应的端口。

 

责任编辑:武晓燕 来源: Linux内核那些事
相关推荐

2011-07-20 12:01:10

网桥交换机

2014-06-17 16:17:58

Docker 1.0Docker

2013-05-14 09:56:37

2021-05-30 07:55:26

虚拟网络Docker

2017-05-16 15:33:42

Python网络爬虫核心技术框架

2017-04-19 21:35:38

Linux调试器工作原理

2022-07-26 07:14:52

Docker宿主命令

2011-07-20 11:59:04

网桥集线器交换机

2011-03-25 09:34:34

Nagios网络监控

2010-08-26 15:30:47

DHCP协议

2020-12-04 14:31:45

大数据Spark

2011-12-20 15:52:03

PhoneGap架构基础工作原理

2024-07-11 08:17:00

2024-10-30 10:06:51

2023-04-06 08:37:24

2021-12-07 07:32:09

kafka架构原理

2011-05-24 10:19:39

VMware快照

2010-08-29 21:45:14

DHCP协议

2016-12-14 19:24:41

2019-10-24 11:10:06

Kubernetes网络运维
点赞
收藏

51CTO技术栈公众号