共计 6421 个字符，预计需要花费 17 分钟才能阅读完成。
还是先来看下 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。
该方法的大致逻辑为：
- 将 sk2->sk_reuseport_cb 字段值赋值给 reuse。
- 将 sk 放入到 reuse->socks 字段代表的数组中。
- 将 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 什么的完全不是问题。
好，就到这里吧。
完。
更多原创文章，请关注我微信公众号：
