多进程可以监听同一端口吗

[[376523]]

当然可以，只要你使用 SO_REUSEPORT 这个参数。

还是先来看下man文档中是怎么说的：

SO_REUSEPORT (since Linux 3.9) 
      Permits multiple AF_INET or AF_INET6 sockets to be bound to an 
      identical socket address.  This option must be set on each 
      socket (including the first socket) prior to calling bind(2) 
      on the socket.  To prevent port hijacking, all of the pro‐ 
      cesses binding to the same address must have the same effec‐ 
      tive UID.  This option can be employed with both TCP and UDP 
      sockets. 
 
      For TCP sockets, this option allows accept(2) load distribu‐ 
      tion in a multi-threaded server to be improved by using a dis‐ 
      tinct listener socket for each thread.  This provides improved 
      load distribution as compared to traditional techniques such 
      using a single accept(2)ing thread that distributes connec‐ 
      tions, or having multiple threads that compete to accept(2) 
      from the same socket. 
 
      For UDP sockets, the use of this option can provide better 
      distribution of incoming datagrams to multiple processes (or 
      threads) as compared to the traditional technique of having 
      multiple processes compete to receive datagrams on the same 
      socket. 

从文档中可以看到，该参数允许多个socket绑定到同一本地地址，即使socket是处于listen状态的。

当多个listen状态的socket绑定到同一地址时，各个socket的accept操作都能接受到新的tcp连接。

很神奇对吧，写段代码测试下：

#include <arpa/inet.h> 
#include <assert.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <strings.h> 
#include <sys/socket.h> 
#include <sys/types.h> 
#include <unistd.h> 
 
static int tcp_listen(char *ip, int port) { 
  int lfd, opt, err; 
  struct sockaddr_in addr; 
 
  lfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 
  assert(lfd != -1); 
 
  opt = 1; 
  err = setsockopt(lfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)); 
  assert(!err); 
 
  bzero(&addr, sizeof(addr)); 
  addr.sin_family = AF_INET; 
  addr.sin_addr.s_addr = inet_addr(ip); 
  addr.sin_port = htons(port); 
 
  err = bind(lfd, (struct sockaddr *)&addr, sizeof(addr)); 
  assert(!err); 
 
  err = listen(lfd, 8); 
  assert(!err); 
 
  return lfd; 
} 
 
int main(int argc, char *argv[]) { 
  int lfd, sfd; 
 
  lfd = tcp_listen("127.0.0.1", 8888); 
  while (1) { 
    sfd = accept(lfd, NULL, NULL); 
    close(sfd); 
    printf("接收到tcp连接：%d\n", sfd); 
  } 
 
  return 0; 
} 

编译并执行该程序：

$ gcc server.c && ./a.out 

看下当前8888端口的所有socket的状态：

$ ss -antp | grep 8888 
LISTEN       0        8              127.0.0.1:8888              0.0.0.0:*       users:(("a.out",pid=32505,fd=3)) 

和我们预想的一样，只有一个socket处于listen状态。

我们再执行一次该程序：

$ gcc server.c && ./a.out 

再次查看8888端口socket的状态：

$ ss -antp | grep 8888 
LISTEN     0        8               127.0.0.1:8888               0.0.0.0:*       users:(("a.out",pid=32607,fd=3)) 
LISTEN     0        8               127.0.0.1:8888               0.0.0.0:*       users:(("a.out",pid=32505,fd=3)) 

此时已经出现两个socket在监听8888端口(注意它们的ip地址也是一样的)，而这两个socket分别属于两个进程。

我们现在再用ncat模拟客户端，连接8888端口：

$ ncat localhost 8888 

重复该操作，建立n个到8888端口的tcp连接，此时两个服务端终端的输出如下。

服务端1：

$ gcc server.c && ./a.out 
接收到tcp连接：4 
接收到tcp连接：4 
接收到tcp连接：4 

服务端2:

$ gcc server.c && ./a.out 
接收到tcp连接：4 
接收到tcp连接：4 

可以看到，tcp连接基本上算是均匀分布到两个服务器上，神奇。

下面我们来看到对应的linux内核代码，看看它是如何实现的。

// net/ipv4/inet_connection_sock.c 
int inet_csk_get_port(struct sock *sk, unsigned short snum) 
{ 
        ... 
        struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo; 
        int ret = 1, port = snum; 
        struct inet_bind_hashbucket *head; 
        ... 
        struct inet_bind_bucket *tb = NULL; 
        ... 
        head = &hinfo->bhash[inet_bhashfn(net, port, 
                                          hinfo->bhash_size)]; 
        ... 
        inet_bind_bucket_for_each(tb, &head->chain) 
                if (net_eq(ib_net(tb), net) && tb->l3mdev == l3mdev && 
                    tb->port == port) 
                        goto tb_found; 
tb_not_found: 
        tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep, 
                                     net, head, port, l3mdev); 
        ... 
tb_found: 
        if (!hlist_empty(&tb->owners)) { 
                ... 
                if (... || sk_reuseport_match(tb, sk)) 
                        goto success; 
                ... 
        } 
success: 
        if (hlist_empty(&tb->owners)) { 
                ... 
                if (sk->sk_reuseport) { 
                        tb->fastreuseport = FASTREUSEPORT_ANY; 
                        ... 
                } else { 
                        tb->fastreuseport = 0; 
                } 
        } else { 
                ... 
        } 
        ... 
} 
EXPORT_SYMBOL_GPL(inet_csk_get_port); 

当我们做bind等操作时，就会调用这个方法，参数snum就是我们要bind的端口。

该方法中，类型struct inet_bind_bucket代表端口bind的具体信息，比如：哪个socket在bind这个端口。

hinfo->bhash是用于存放struct inet_bind_bucket实例的hashmap。

该方法先从hinfo->bhash这个hashmap中找，该端口是否已经被bind过，如果没有，则新创建一个tb，比如我们第一次listen操作时，该端口就没有被使用，所以会新创建一个tb。

新创建的tb，它的tb->owners是empty，此时，如果我们设置了SO_REUSEPORT参数，那sk->sk_reuseport字段值就会大于0，也就是说，第一次listen操作之后，tb->fastreuseport的值被设置为FASTREUSEPORT_ANY(大于0)。

当我们第二次做listen操作时，又会进入到这个方法，此时hinfo->bhash的map中存在相同端口的tb，所以会goto到tb_found部分。

因为之前的listen操作会把其对应的socket放入到tb->owners中，所以第二次的listen操作，tb->owners不为empty。

进而，逻辑处理会进入到sk_reuseport_match方法，如果此方法返回true，则内核会允许第二次listen操作使用该本地地址。

我们看下sk_reuseport_match方法：

// net/ipv4/inet_connection_sock.c 
static inline int sk_reuseport_match(struct inet_bind_bucket *tb, 
                                     struct sock *sk) 
{ 
        ... 
        if (tb->fastreuseport <= 0) 
                return 0; 
        if (!sk->sk_reuseport) 
                return 0; 
        ... 
        if (tb->fastreuseport == FASTREUSEPORT_ANY) 
                return 1; 
        ... 
} 

由于上一次listen操作，tb->fastreuseport被设置为FASTREUSEPORT_ANY，而此次listen操作的socket，又设置了SO_REUSEPORT参数，即sk->sk_reuseport值大于0，所以，该方法最终返回true。

由上可见，设置了SO_REUSEPORT参数之后，第二次listen中的bind操作是没用问题的，我们再看下对应的listen操作：

// net/core/sock_reuseport.c 
int reuseport_add_sock(struct sock *sk, struct sock *sk2, bool bind_inany) 
{ 
        struct sock_reuseport *old_reuse, *reuse; 
        ... 
        reuse = rcu_dereference_protected(sk2->sk_reuseport_cb, 
                                          lockdep_is_held(&reuseport_lock)); 
        ... 
        reuse->socks[reuse->num_socks] = sk; 
        ... 
        reuse->num_socks++; 
        rcu_assign_pointer(sk->sk_reuseport_cb, reuse); 
        ... 
} 
EXPORT_SYMBOL(reuseport_add_sock); 

listen方法最终会调用上面的方法，在该方法中，sk代表第二次listen操作的socket，sk2代表第一次listen操作的socket。

该方法的大致逻辑为：

1. 将sk2->sk_reuseport_cb字段值赋值给reuse。

2. 将sk放入到reuse->socks字段代表的数组中。

3. 将sk的sk_reuseport_cb字段也指向这个数组。

也就是说，该方法会将所有第二次及其以后的listen操作的socket放入到reuse->socks字段代表的数组中(第一次listen操作的socket在创建struct sock_reuseport实例时就已经被放入到该数组中了)，同时，将所有listen的socket的sk->sk_reuseport_cb字段，都指向reuse，这样，我们就可以通过listen的socket的sk_reuseport_cb字段，拿到struct sock_reuseport实例，进而可以拿到所有其他的listen同一端口的socket。

到现在为止，reuseport是如何实现的基本就明朗了，当有新的tcp连接来时，只要我们找到监听该端口的一个listen的socket，就等于拿到了所有设置了SO_REUSEPORT参数，并监听同样端口的其他socket，我们只需随机挑一个socket，然后让它完成之后的tcp连接建立过程，这样我们就可以实现tcp连接均匀负载到这些listen socket上了。

看下相应代码：

// net/core/sock_reuseport.c 
struct sock *reuseport_select_sock(struct sock *sk, 
                                   u32 hash, 
                                   struct sk_buff *skb, 
                                   int hdr_len) 
{ 
        struct sock_reuseport *reuse; 
        ... 
        struct sock *sk2 = NULL; 
        u16 socks; 
        ... 
        reuse = rcu_dereference(sk->sk_reuseport_cb); 
        ... 
        socks = READ_ONCE(reuse->num_socks); 
        if (likely(socks)) { 
                ... 
                if (!sk2) 
                        sk2 = reuse->socks[reciprocal_scale(hash, socks)]; 
        } 
        ... 
        return sk2; 
} 
EXPORT_SYMBOL(reuseport_select_sock); 

看到了吧，该方法中，最后使用了reciprocal_scale方法，计算被选中的listen socket的索引，最后返回这个listen socket继续处理tcp连接请求。

看下reciprocal_scale方法是如何实现的：

// include/linux/kernel.h 
/** 
 * reciprocal_scale - "scale" a value into range [0, ep_ro) 
 * ... 
 */ 
static inline u32 reciprocal_scale(u32 val, u32 ep_ro) 
{ 
        return (u32)(((u64) val * ep_ro) >> 32); 
} 

算法虽然我们看不懂，但通过其注释我们可以知道，它返回的值的区间是[0, ep_ro)，再结合上面的reuseport_select_sock方法我们可以确定，返回的就是所有listen socket的数组下标索引。

至此，有关SO_REUSEPORT参数的内容我们就讲完了。

上篇文章 socket的SO_REUSEADDR参数全面分析 中，我们分析了SO_REUSEADDR参数，那这个参数和SO_REUSEADDR又有什么区别呢?

SO_REUSEPORT参数是SO_REUSEADDR参数的超集，两个参数目的都是为了重复使用本地地址，但SO_REUSEADDR不允许处于listen状态的地址重复使用，而SO_REUSEPORT允许，同时，SO_REUSEPORT参数还会把新来的tcp连接负载均衡到各个listen socket上，为我们tcp服务器编程，提供了一种新的模式。

其实，该参数在我上次写的socks5代理那个项目就有用到(是的，我又用rust实现了一版socks5代理)，通过使用该参数，我可以开多个进程同时处理socks5代理请求，现在使用下来的感受是，真的非常快，用Google什么的完全不是问题。

好，就到这里吧。

本文转载自微信公众号「卯时卯刻」，可以通过以下二维码关注。转载本文请联系卯时卯刻公众号。