[[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什么的完全不是問題。

好，就到這里吧。

本文轉載自微信公眾號「卯時卯刻」，可以通過以下二維碼關注。轉載本文請聯系卯時卯刻公眾號。