Linux 网络命名空间
在 Linux 上通过 veth 可以创建出许多的虚拟设备。通过 Bridge 模拟以太网交换机的方式可以让这些网络设备之间进行通信。不过虚拟化中还有很重要的一步,那就是隔离。借用 Docker 的概念来说,那就是不能让 A 容器用到 B 容器的设备,甚至连看一眼都不可以。只有这样才能保证不同的容器之间复用硬件资源的同时,还不会影响其它容器的正常运行。
在 Linux 上实现隔离的技术手段就是 namespace。通过 namespace 可以隔离容器的进程 PID、文件系统挂载点、主机名等多种资源。重点要介绍的是网络 namespace,简称 netns。它可以为不同的命名空间从逻辑上提供独立的网络协议栈,具体包括网络设备、路由表、arp表、iptables、以及套接字(socket)等。使得不同的网络空间就都好像运行在独立的网络中一样。
Linux 网络命名空间 - 图1
来挖一挖 netns 的内部实现。

一、如何使用 netns

由于平时的开发工作很少涉及网络空间,所以先来看一下网络空间是如何使用的吧。来创建一个新的命名空间net1。再创建一对儿 veth,将 veth 的一头放到 net1 中。分别查看一下母机和 net1 空间内的 iptable、设备等。最后让两个命名空间之间进行通信。
Linux 网络命名空间 - 图2
下面是详细的使用过程。首先来创建一个新的网络命名空间 - net1。

  1. # ip netns add net1

来查看一下它的 iptable、路由表、以及网络设备

  1. # ip netns exec net1 route
  2. Kernel IP routing table
  3. Destination Gateway Genmask Flags Metric Ref Use Iface
  4. # ip netns exec net1 iptables -L
  5. ip netns exec net1 iptables -L
  6. Chain INPUT (policy ACCEPT)
  7. target prot opt source destination
  8. ......
  9. # ip netns exec net1 ip link list
  10. lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT qlen 1
  11. link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

由于是新创建的 netns,所以上述的输出中路由表、iptable规则都是空的。不过这个命名空间中初始的情况下就存在一个 lo 本地环回设备,只不过默认是 DOWN(未启动)状态。
接下来创建一对儿 veth,并把 veth 的一头添加给它。

  1. # ip link add veth1 type veth peer name veth1_p
  2. # ip link set veth1 netns net1

在母机上查看一下当前的设备,发现已经看不到 veth1 这个网卡设备了,只能看到 veth1_p。

  1. # ip link list
  2. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 ...
  3. 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 ...
  4. 3: eth1: <BROADCAST,MULTICAST> mtu 1500 ...
  5. 45: veth1_p@if46: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
  6. link/ether 0e:13:18:0a:98:9c brd ff:ff:ff:ff:ff:ff link-netnsid 0

这个新设备已经跑到 net1 这个网络空间里了。

  1. # ip netns exec net1 ip link list
  2. 1: lo: <LOOPBACK> mtu 65536 ...
  3. 46: veth1@if45: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT qlen 1000
  4. link/ether 7e:cd:ec:1c:5d:7a brd ff:ff:ff:ff:ff:ff link-netnsid 0

把这对儿 veth 分别配置上 ip,并把它们启动起来

  1. # ip addr add 192.168.0.100/24 dev veth1_p
  2. # ip netns exec net1 ip addr add 192.168.0.101/24 dev veth1
  3. # ip netns exec net1 ip link set dev veth1_p up
  4. # ip netns exec net1 ip link set dev veth1 up

在母机和 net1 中分别执行 ifconfig 查看当前启动的网络设备。

  1. # ifconfig
  2. eth0: ...
  3. lo: ...
  4. veth1_p: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
  5. inet 192.168.0.100 netmask 255.255.255.0 broadcast 0.0.0.0
  6. ...
  7. # ip netns exec net1 ifconfig
  8. veth1: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
  9. inet 192.168.0.101 netmask 255.255.255.0 broadcast 0.0.0.0
  10. ...

来让它和母机通信一下试试。

  1. # ip netns exec net1 ping 192.168.0.100 -I veth1
  2. PING 192.168.0.100 (192.168.0.100) from 192.168.0.101 veth1: 56(84) bytes of data.
  3. 64 bytes from 192.168.0.100: icmp_seq=1 ttl=64 time=0.027 ms
  4. 64 bytes from 192.168.0.100: icmp_seq=2 ttl=64 time=0.010 ms

好了,现在一个新网络命名空间创建实验就结束了。在这个空间里,网络设备、路由表、arp表、iptables都是独立的,不会和母机上的冲突,也不会和其它空间里的产生干扰。而且还可以通过 veth 来和其它空间下的网络进行通信。
想快速做这个实验的同学可以使用这个makefile,见 https://github.com/yanfeizhang/coder-kung-fu/tree/main/tests/network/test05

二、内核中 namespace 的定义

在内核中,很多组件都是和 namespace 有关系的,先来看看这个关联关系是如何定义的。后面再看下 namespace 本身的详细结构。

2.1 归属到 namespace 的东东

在 Linux 中,很多平常熟悉的概念都是归属到某一个特定的网络 namespace 中的,比如进程、网卡设备、socket 等等。
Linux 中每个进程(线程)都是用 task_struct 来表示的。每个 task_struct 都要关联到一个 namespace 对象 nsproxy,而 nsproxy 又包含了 netns。对于网卡设备和 socket 来说,通过自己的成员来直接表明自己的归属。
Linux 网络命名空间 - 图3
拿网络设备来举例,只有归属到当前 netns 下的时候才能够通过 ifconfig 看到,否则是不可见的。详细来看看这几个数据结构的定义,先来看进程。

  1. //file:include/linux/sched.h
  2. struct task_struct {
  3. /* namespaces */
  4. struct nsproxy *nsproxy;
  5. ......
  6. }

命名空间的核心数据结构是上面的这个 struct nsproxy。所有类型的 namespace(包括 pid、文件系统挂载点、网络栈等等)都是在这里定义的。

//file: include/linux/nsproxy.h
struct nsproxy {
 struct uts_namespace *uts_ns; // 主机名
 struct ipc_namespace *ipc_ns; // IPC
 struct mnt_namespace *mnt_ns; // 文件系统挂载点
 struct pid_namespace *pid_ns; // 进程标号
 struct net       *net_ns;  // 网络协议栈
};

其中 struct net *net_ns 就是要讨论的网络命名空间。它的详细定义待会再说。接着再看表示网络设备的 struct net_device,它也是要归属到某一个网络空间下的。

//file: include/linux/netdevice.h
struct net_device{
 //设备名
 char   name[IFNAMSIZ];

 //网络命名空间
 struct net  *nd_net;

 ...
}

所有的网络设备刚创建出来都是在宿主机默认网络空间下的。可以通过ip link set 设备名 netns 网络空间名将设备移动到另外一个空间里去。前面的实验里,当 veth 1 移动到 net1 下的时候,该设备在宿主机下“消失”了,在 net1 下就能看到了。
还有经常用的 socket,也是归属在某一个网络命名空间下的。

//file:
struct sock_common {
 struct net   *skc_net;
}

2.2 网络 namespace 定义

来看网络 namespace 的主要数据结构 struct net 的定义。
Linux 网络命名空间 - 图4
可见每个 net 下都包含了自己的路由表、iptable 以及内核参数配置等等。来看具体的代码。

//file:include/net/net_namespace.h
struct net {
 //每个 net 中都有一个回环设备
 struct net_device       *loopback_dev;          /* The loopback */

 //路由表、netfilter都在这里
 struct netns_ipv4 ipv4;
 ......

 unsigned int  proc_inum;
}

由上述定义可见,每一个 netns 中都有一个 loopback_dev,这就是为什么在第一节中看到刚创建出来的空间里就能看到一个 lo 设备的底层原因。
网络 netspace 中最核心的数据结构是 struct netns_ipv4 ipv4。在这个数据结构里,定义了每一个网络空间专属的路由表、ipfilter 以及各种内核参数。

//file: include/net/netns/ipv4.h
struct netns_ipv4 {
 //路由表 
 struct fib_table *fib_local;
 struct fib_table *fib_main;
 struct fib_table *fib_default;

 //ip表
 struct xt_table  *iptable_filter;
 struct xt_table  *iptable_raw;
 struct xt_table  *arptable_filter;

 //内核参数
 long sysctl_tcp_mem[3];
 ...
}

三、网络 namespace 的创建

回顾第一小节中,实验步骤主要是创建了一个 netns,为其添加了一个 veth 设备。在这节中来窥探一下刚才的实验步骤内部到底是如何运行的。

3.1 进程与网络命名空间

Linux 上存在一个默认的网络命名空间,Linux 中的 1 号进程初始使用该默认空间。Linux 上其它所有进程都是由 1 号进程派生出来的,在派生 clone 的时候如果没有额外特别指定,所有的进程都将共享这个默认网络空间。
Linux 网络命名空间 - 图5
在 clone 里可以指定创建新进程时的 flag,都是 CLONE_ 开头的。和 namespace 有的的标志位有 CLONE_NEWIPC、CLONE_NEWNET、CLONE_NEWNS、CLONE_NEWPID 等等。如果在创建进程时指定了 CLONE_NEWNET 标记位,那么该进程将会创建并使用新的 netns。
其实内核提供了三种操作命名空间的方式,分别是 clone、setns 和 unshare。这里只用 clone 来举例,ip netns add 使用的是 unshare,原理和 clone 是类似的。
Linux 网络命名空间 - 图6
先来看下默认的网络命名空间的初始化过程。

//file: init/init_task.c
struct task_struct init_task = INIT_TASK(init_task);

//file: include/linux/init_task.h
#define INIT_TASK(tsk)  \
{
 ...
  .nsproxy = &init_nsproxy, \
}

上面的代码是在初始化第 1 号进程。可见 nsproxy 是已经创建好的 init_nsproxy。再看 init_nsproxy 是如何创建的。

//file: kernel/nsproxy.c
struct nsproxy init_nsproxy = {
 .uts_ns = &init_uts_ns,
 .ipc_ns = &init_ipc_ns,
 .mnt_ns = NULL,
 .pid_ns = &init_pid_ns,
 .net_ns = &init_net,
};

初始的 init_nsproxy 里将多个命名空间都进行了初始化,其中关注的网络命名空间,用的是默认网络空间 init_net。它是系统初始化的时候就创建好的。

//file: net/core/net_namespace.c
struct net init_net = {
 .dev_base_head = LIST_HEAD_INIT(init_net.dev_base_head),
};
EXPORT_SYMBOL(init_net);
//file: net/core/net_namespace.c
static int __init net_ns_init(void)
{
 ...
 setup_net(&init_net, &init_user_ns);
 ...
 register_pernet_subsys(&net_ns_ops);
 return 0;
}

上面的 setup_net 方法中对这个默认网络命名空间进行初始化。
看到这里清楚了 1 号进程的命名空间初始化过程。Linux 中所有的进程都是由这个 1 号进程创建的。如果创建子进程过程中没有指定 CLONE_NEWNET 这个 flag 的话,就直接还使用这个默认的网络空间。
如果创建进程过程中指定了 CLONE_NEWNET,那么就会重新申请一个网络命名空间出来。见如下的关键函数 copy_net_ns(它的调用链是 do_fork => copy_process => copy_namespaces => create_new_namespaces => copy_net_ns)。

//file: net/core/net_namespace.c
struct net *copy_net_ns(unsigned long flags,
   struct user_namespace *user_ns, struct net *old_net)
{
 struct net *net;

 // 重要!!!
 // 不指定 CLONE_NEWNET 就不会创建新的网络命名空间
 if (!(flags & CLONE_NEWNET))
  return get_net(old_net);

 //申请新网络命名空间并初始化
 net = net_alloc();
 rv = setup_net(net, user_ns);
 ...
}

记住 setup_net 是初始化网络命名空间的,这个函数接下来还会提到。

3.2 命名空间内的网络子系统初始化

命名空间内的各个组件都是在 setup_net 时初始化的,包括路由表、tcp 的 proc 伪文件系统、iptable 规则读取等等,所以这个小节也是蛮重要的。
由于内核网络模块的复杂性,在内核中将网络模块划分成了各个子系统。每个子系统都定义了一个

//file: include/net/net_namespace.h
struct pernet_operations {
 // 链表指针
 struct list_head list;

 // 子系统的初始化函数
 int (*init)(struct net *net);

 // 网络命名空间每个子系统的退出函数
 void (*exit)(struct net *net);
 void (*exit_batch)(struct list_head *net_exit_list);
 int *id;
 size_t size;
};

各个子系统通过调用 register_pernet_subsys 或 register_pernet_device 将其初始化函数注册到网络命名空间系统的全局链表 pernet_list 中。在源码目录下用这两个函数搜索的话,会看到各个子系统的注册过程。
Linux 网络命名空间 - 图7
拿 register_pernet_subsys 来举例,来简单看下它是如何将子系统都注册到 pernet_list 中的。

//file: net/core/net_namespace.c
static struct list_head *first_device = &pernet_list;
int register_pernet_subsys(struct pernet_operations *ops)
{
 error =  register_pernet_operations(first_device, ops);
 ...
}

register_pernet_operations 又会调用 __register_pernet_operations。

//file: include/net/net_namespace.h
#define for_each_net(VAR)    \
 list_for_each_entry(VAR, &net_namespace_list, list)

//file: net/core/net_namespace.c
static int __register_pernet_operations(struct list_head *list,
     struct pernet_operations *ops)
{
 struct net *net;

 list_add_tail(&ops->list, list);
 if (ops->init || (ops->id && ops->size)) {
  for_each_net(net) {
   error = ops_init(ops, net);
   ...
}

在上面 list_add_tail 这一行,完成了将子系统传入的 struct pernet_operations *ops 链入到 pernet_list 中。并注意一下,for_each_net 是遍历了所有的网络命名空间,然后在这个空间内执行了 ops_init 初始化。
这个初始化是网络子系统在注册的时候调用的。同样当新的命名空间创建时,会遍历该全局变量 pernet_list,执行每个子模块注册上来的初始化函数。再回到 3.1.1 里提到的 setup_net 函数。

//file: net/core/net_namespace.c
static __net_init int setup_net(struct net *net, struct user_namespace *user_ns)
{
 const struct pernet_operations *ops;
 list_for_each_entry(ops, &pernet_list, list) {
  error = ops_init(ops, net);
 ...
}
//file: net/core/net_namespace.c
static int ops_init(const struct pernet_operations *ops, struct net *net)
{
 if (ops->init)
  err = ops->init(net);
}

在创建新命名空间调用到 setup_net 时,会通过 pernet_list 找到所有的网络子系统,把它们都 init 一遍。
拿路由表来举例,路由表子系统通过 register_pernet_subsys 将 fib_net_ops 注册进来了。

//file: net/ipv4/fib_frontend.c
static struct pernet_operations fib_net_ops = {
 .init = fib_net_init,
 .exit = fib_net_exit,
};

void __init ip_fib_init(void)
{
 register_pernet_subsys(&fib_net_ops);
 ...
}

这样每当创建一个新的命名空间的时候,就会调用 fib_net_init 来创建一套独立的路由规则
再比如拿 iptable 中的 nat 表来说,也是一样。每当创建新命名空间的时候,就会调用 iptable_nat_net_init 创建一套新的表

//file: net/ipv4/netfilter/iptable_nat.c
static struct pernet_operations iptable_nat_net_ops = {
 .init = iptable_nat_net_init,
 .exit = iptable_nat_net_exit,
};
static int __init iptable_nat_init(void)
{
 err = register_pernet_subsys(&iptable_nat_net_ops);
 ...

3.3 添加设备

在一个设备刚刚创建出来的时候,它是属于默认网络命名空间 init_net 的,包括 veth 设备。不过可以在创建完后修改设备到新的网络命名空间。
Linux 网络命名空间 - 图8
拿 veth 设备来举例,它是在创建时的源码 alloc_netdev_mqs 中设置到 init_net 上的。(执行代码路径:veth_newlink => rtnl_create_link => alloc_netdev_mqs)

//file: core/dev.c
struct net_device *alloc_netdev_mqs(...)
{
 dev_net_set(dev, &init_net);
}
//file: include/linux/netdevice.h
void dev_net_set(struct net_device *dev,struct net *net)
{
 release_net(dev->nd_net);
 dev->nd_net = hold_net(net);
}

在执行 修改设备所属的 namespace 的时候,会将 dev->nd_net 再指向新的 netns。对于 veth 来说,它包含了两个设备。这两个设备可以放在不同的 namespace 中。这就是 Docker 容器和其母机或者其它容器通信的基础。

//file: core/dev.c
int dev_change_net_namespace(struct net_device *dev, struct net *net, ...)
{
 ...
 dev_net_set(dev, net)
}

四、在 namespace 下的网络收发

在前面一节中,知道了内核是如何创建 netns 出来,也了解了网络设备是如何添加到其它命名空间里的。在这一小节,来看看,当考虑到网络命名空间的时候,网络包的收发又是怎么样的呢?

4.1 socket 与网络命名空间

首先来考虑的就是熟悉的 socket。其实每个 socket 都是归属于某一个网络命名空间的,这个关联关系在上面的 2.1 小节提到过。
到底归属那个 netns,这是由创建这个 socket 的进程所属的 netns 来决定。当在某个进程里创建 socket 的时候,内核就会把当前进程的 nsproxy->net_ns 找出来,并把它赋值给 socket 上的网络命名空间成员 skc_net。
在默认下,创建的 socket 都属于默认的网络命名空间 init_net
Linux 网络命名空间 - 图9
来展开看下 socket 是如何被放到某个网络命名空间中的。在 socket 中,用来保存和网络命名空间归属关系的变量是 skc_net,如下。

//file: include/net/sock.h
struct sock_common {
 ...
 struct net   *skc_net;
}

接下来就是 socket 创建的时候,内核中可以通过 current->nsproxy->net_ns 把当前进程所属的 netns 找出来,最终把 socket 中的 sk_net 成员和该命名空间建立好了联系。

//file: net/socket.c
int sock_create(int family, int type, int protocol, struct socket **res)
{
 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
}

在 socket_create 中,看到 current->nsproxy->net_ns 了吧,它获取到了进程的 netns。再依次经过__sock_create => inet_create => sk_alloc,调用到 sock_net_set 的时候,成功设置了新 socket 和 netns 的关联关系。

//file: include/net/sock.h
static inline
void sock_net_set(struct sock *sk, struct net *net)
{
 write_pnet(&sk->sk_net, net);
}

4.2 网络包的收发过程

本小节的不再重复赘述这个收发过程,就以网络包发送过程中的路由功能为例,来看一下网络在传输的时候是如何使用到 netns 的。其它收发过程中的各个步骤也都是类似的。
Linux 网络命名空间 - 图10
大致的原理就是 socket 上记录了其归属的网络命名空间。需要查找路由表之前先找到该命名空间,再找到命名空间里的路由表,然后再开始执行查找。这样,各个命名空间中的路由过程就都隔离开了。
在发送过程中在 IP 层的发送函数 ip_queue_xmit 中调用 ip_route_output_ports 来查找路由项。

//file: net/ipv4/ip_output.c
int ip_queue_xmit(struct sk_buff *skb, struct flowi *fl)
{
 rt = ip_route_output_ports(sock_net(sk), fl4, sk,
     daddr, inet->inet_saddr,
     ...);
}

注意上面的 sock_net(sk) 这一步,在这里将 socket 上记录的命名空间 struct net *sk_net 给找了出来。

//file: include/net/sock.h
static inline struct net *sock_net(const struct sock *sk)
{
 return read_pnet(&sk->sk_net);
}

找到命名空间以后,就会将它(以 struct net * 指针的形式)一路透传到后面的各个函数中。在路由查找最后会执行到 fib_lookup,来看下这个函数的源码。
路由查找的调用链条有点长,是 ip_route_output_ports => ->ip_route_output_flow => __ip_route_output_key() => ip_route_output_key_hash => ip_route_output_key_hash_rcu)

//file: include/net/ip_fib.h
static inline int fib_lookup(struct net *net, ...)
{
 struct fib_table *table;
 table = fib_get_table(net, RT_TABLE_LOCAL);
 table = fib_get_table(net, RT_TABLE_MAIN);
 ...
}

static inline struct fib_table *fib_get_table(struct net *net, u32 id)
{
 ptr = id == RT_TABLE_LOCAL ?
  &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
  &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
 return hlist_entry(ptr->first, struct fib_table, tb_hlist);
}

由上述代码可见,在路由过程中是根据前面步骤中确定好的命名空间 struct net net 来查找路由项的。不同的命名空间有不同的 net 变量,所以不同的 netns 中自然也就可以配置不同的路由表了
网络收发过程中其它步骤也是类似的,涉及到需要隔离的地方,都是通过命名空间( struct net
) 去查找的。

五、结论

Linux 的网络 namespace 实现了独立协议栈的隔离。这个说法其实不是很准确,内核网络代码只有一套,并没有隔离。
它是通过为不同空间创建不同的 struct net 对象。每个 struct net 中都有独立的路由表、iptable 等数据结构。每个设备、每个 socket 上也都有指针指明自己归属那个 netns。通过这种方法从逻辑上看起来好像是真的有多个协议栈一样
Linux 网络命名空间 - 图11
这样,就为一台物理上创建出多个逻辑上的协议栈,为 Docker 容器的诞生提供了可能。
Linux 网络命名空间 - 图12
在上面的示例中,Docker1 和 Docker2 都可以分别拥有自己独立的网卡设备,配置自己的路由规则、iptable。从而使得他们的网络功能不会相互影响。