reuseaddr和reuseport
2020-12-13 本文已影响0人
分享放大价值
对于reuseaddr和reuseport的演进，可以参考这篇文章，本文主要基于kernel 3.18.79 版本分析下这两个参数如何生效。
SO_REUSEADDR
- 解决server重启的问题
server端调用close，client还没有调用close，则server端socket处于FIN_WAIT2状态，持续时间60s，此时server重启会失败，在bind时会报错 Address already in use。
或者server端先调用close，client后调用close，则server会处于TIME_WAIT状态，持续时间也是60s，此时server重启会失败，在bind时也会报错 Address already in use。
解决方法：
套接字bind前设置SO_REUSEADDR，或者 SO_REUSEPORT
- 解决ip为零的通配符问题
例如: socketA绑定了0.0.0.0:2222，socketB绑定10.164.129.22:2222时，或者 socketA绑定了10.164.129.22:2222，socketB绑定0.0.0.0:2222时，都会报错 Address already in use。因为0.0.0.0相当于通配符，可以匹配到10.164.129.22，在没有设置地址复用或者端口复用前就会有此问题。
解决方法：
方案1: 如果socketA调用bind后，又调用了listen，则fastreuse 会恢复为0(即使socketA在bind前设置了SO_REUSEADDR)，此时即使socketB在bind前设置了SO_REUSEADDR也不管用。
socketA和socketB在bind前设置SO_REUSEADDR， 并且socketB必须在socketA调用listen前调用bind。
方案2: socketA和socketB在bind前均设置了SO_REUSEPORT。
方案3: socketB在调用bind前设置 setsockopt(fd, SOL_TCP, TCP_REPAIR, &status, sizeof(int)) 进行强制bind，而不用管socketA是什么状态。
SO_REUSEPORT
SO_REUSEPORT支持多个进程或者线程绑定到同一端口，提高服务器程序的性能，解决的问题：
a. 允许多个套接字 bind()/listen() 同一个TCP/UDP端口
每一个线程拥有自己的服务器套接字
在服务器套接字上没有了锁的竞争
b. 内核层面实现负载均衡
c. 安全层面，监听同一个端口的套接字只能位于同一个用户下面
如何设置
可以在调用bind绑定端口号之前，通过如下调用设置socket的reuseaddr或者reuseport
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &status, sizeof(int))
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &status, sizeof(int))
kernel中对应代码如下
sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
case SO_REUSEADDR:
sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
break;
case SO_REUSEPORT:
sk->sk_reuseport = valbool;
出问题场景下(报错 Address already in use)，代码分析
a. socketA 调用bind时
//在内核中会调用inet_bind,接着调用inet_csk_get_port，在函数
//inet_csk_get_port中，先在bind hash表查找是否有其他socket绑
//定此port了，第一次bind肯定查找失败，跳转到tb_not_found
have_snum:
//在bind hash表中查找，hash key为net和local port
head = &hashinfo->bhash[inet_bhashfn(net, snum, hashinfo->bhash_size)];
spin_lock(&head->lock);
inet_bind_bucket_for_each(tb, &head->chain)
if (net_eq(ib_net(tb), net) && tb->port == snum)
goto tb_found;
tb = NULL;
goto tb_not_found;
tb_not_found:
ret = 1;
//创建hash表项，并将表项添加到bind hash表中
if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
net, head, snum)) == NULL)
goto fail_unlock;
//第一次创建，并且是第一次调用，tb->owners为空
if (hlist_empty(&tb->owners)) {
//sk如果设置了SO_REUSEADDR，并且socketA不为TCP_LISTEN状态,
//则设置tb->fastreuse为1
if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
tb->fastreuse = 1;
else
tb->fastreuse = 0;
//sk如果设置了SO_REUSEPORT，则设置fastreuseport 为1，设置fastuid为uid
if (sk->sk_reuseport) {
tb->fastreuseport = 1;
tb->fastuid = uid;
} else
tb->fastreuseport = 0;
} else {
//调用listen时，会再次调用inet_csk_get_port，此情况下才会走到此else分支。
if (tb->fastreuse &&
(!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
tb->fastreuse = 0;
if (tb->fastreuseport &&
(!sk->sk_reuseport || !uid_eq(tb->fastuid, uid)))
tb->fastreuseport = 0;
}
success:
//将tb赋给icsk_bind_hash
if (!inet_csk(sk)->icsk_bind_hash)
inet_bind_hash(sk, tb, snum);
WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
ret = 0;
}
b. socketA 调用listen时
sk->sk_state = TCP_LISTEN;
if (!sk->sk_prot->get_port(sk, inet->inet_num)) {
inet->inet_sport = htons(inet->inet_num);
sk_dst_reset(sk);
sk->sk_prot->hash(sk);
return 0;
}
//在函数inet_csk_get_port中，先在bind hash表查找是否有其他
//socket绑定此port了，这次会查找成功，跳转到tb_found
have_snum:
//在bind hash表中查找，hash key为net和local port
head = &hashinfo->bhash[inet_bhashfn(net, snum, hashinfo->bhash_size)];
spin_lock(&head->lock);
inet_bind_bucket_for_each(tb, &head->chain)
if (net_eq(ib_net(tb), net) && tb->port == snum)
goto tb_found;
tb = NULL;
goto tb_not_found;
tb_found:
//不为空
if (!hlist_empty(&tb->owners)) {
//没有设置此标志
if (sk->sk_reuse == SK_FORCE_REUSE)
goto success;
//fastreuse 和fastureseport都为0，走else分支
if (((tb->fastreuse > 0 &&
sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
(tb->fastreuseport > 0 &&
sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
smallest_size == -1) {
goto success;
} else {
ret = 1;
//执行函数 inet_csk_bind_conflict，在调用listen情况下，会返回false，说明没有冲突的sk
if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
....
}
}
}
tb_not_found:
ret = 1;
if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
net, head, snum)) == NULL)
goto fail_unlock;
//tb->owners不为空，执行else分支
if (hlist_empty(&tb->owners)) {
//sk如果设置SO_REUSEADDR，并且socketA不为
//TCP_LISTEN状态,则设置tb->fastreuse为1
if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
tb->fastreuse = 1;
else
tb->fastreuse = 0;
//sk如果设置SO_REUSEPORT，则设置fastreuseport 为1，设置fastuid
if (sk->sk_reuseport) {
tb->fastreuseport = 1;
tb->fastuid = uid;
} else
tb->fastreuseport = 0;
} else {
//调用listen时，会再次调用inet_csk_get_port，此情况下才会走到此else分支。
//如果socketA调用bind后，又调用了listen，则fastreuse 会恢复为0(即使socketA在bind前设
//置了SO_REUSEADDR)。此时即使socketB在bind前设置了SO_REUSEADDR也不管用。
//但是fastreuseport 不会被恢复为0，
if (tb->fastreuse &&
(!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
tb->fastreuse = 0;
if (tb->fastreuseport &&
(!sk->sk_reuseport || !uid_eq(tb->fastuid, uid)))
tb->fastreuseport = 0;
}
success:
//icsk_bind_hash已经有值
if (!inet_csk(sk)->icsk_bind_hash)
inet_bind_hash(sk, tb, snum);
WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
ret = 0;
}
int inet_csk_bind_conflict(const struct sock *sk,
const struct inet_bind_bucket *tb, bool relax)
{
struct sock *sk2;
int reuse = sk->sk_reuse;
int reuseport = sk->sk_reuseport;
kuid_t uid = sock_i_uid((struct sock *)sk);
/*
* Unlike other sk lookup places we do not check
* for sk_net here, since _all_ the socks listed
* in tb->owners list belong to the same net - the
* one this bucket belongs to.
*/
sk_for_each_bound(sk2, &tb->owners) {
//因为是同一个sk，所以sk等于sk2，循环完后，sk2为NULL
if (sk != sk2 &&
!inet_v6_ipv6only(sk2) &&
(!sk->sk_bound_dev_if ||
!sk2->sk_bound_dev_if ||
sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
if ((!reuse || !sk2->sk_reuse ||
sk2->sk_state == TCP_LISTEN) &&
(!reuseport || !sk2->sk_reuseport ||
(sk2->sk_state != TCP_TIME_WAIT &&
!uid_eq(uid, sock_i_uid(sk2))))) {
if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
break;
}
if (!relax && reuse && sk2->sk_reuse &&
sk2->sk_state != TCP_LISTEN) {
if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
break;
}
}
}
return sk2 != NULL;
}
c. socketB 调用bind函数时，
//在函数inet_csk_get_port中，先在bind hash表查找是否有其他
//socket绑定此port了，这次会查找成功，跳转到tb_found
have_snum:
//在bind hash表中查找，hash key为net和local port
head = &hashinfo->bhash[inet_bhashfn(net, snum,
hashinfo->bhash_size)];
spin_lock(&head->lock);
inet_bind_bucket_for_each(tb, &head->chain)
if (net_eq(ib_net(tb), net) && tb->port == snum)
goto tb_found;
tb = NULL;
goto tb_not_found;
tb_found:
//tb->owners不为空
if (!hlist_empty(&tb->owners)) {
//没有设置此标志
//如果socketB设置了TCP_REPAIR,则强制bind成功
if (sk->sk_reuse == SK_FORCE_REUSE)
goto success;
//如果socketA没有设置reuseaddr和reuseport，则fastreuse 和fastureseport都为0，走else分支。
//如果tb的fastreuse不为0，即socketA设置了reuseaddr，并且还没有调用listen，如果
//socketB也设置了reuseaddr，则socketB可以bind成功。
//或者tb的fastreuseport不为0，即socketA设置了reuseport，如果socketB也设置了reuseport，则socketB可以bind成功。
if (((tb->fastreuse > 0 &&
sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
(tb->fastreuseport > 0 &&
sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
smallest_size == -1) {
goto success;
} else {
ret = 1;
//执行函数inet_csk_bind_conflict，在此例会返回true，说明找到了冲突的sk
if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) {
//不满足if条件，跳转到fail_unlock，返回值为1.
//在inet_bind中，判断如果返回值为1，则设置err为EADDRINUSE
if (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||
(tb->fastreuseport > 0 &&
sk->sk_reuseport && uid_eq(tb->fastuid, uid))) &&
smallest_size != -1 && --attempts >= 0) {
spin_unlock(&head->lock);
goto again;
}
goto fail_unlock;
}
}
}
fail_unlock:
spin_unlock(&head->lock);
fail:
local_bh_enable();
return ret;
}
int inet_csk_bind_conflict(const struct sock *sk,
const struct inet_bind_bucket *tb, bool relax)
{
struct sock *sk2;
int reuse = sk->sk_reuse;
int reuseport = sk->sk_reuseport;
kuid_t uid = sock_i_uid((struct sock *)sk);
/*
* Unlike other sk lookup places we do not check
* for sk_net here, since _all_ the socks listed
* in tb->owners list belong to the same net - the
* one this bucket belongs to.
*/
sk_for_each_bound(sk2, &tb->owners) {
if (sk != sk2 &&
!inet_v6_ipv6only(sk2) &&
(!sk->sk_bound_dev_if ||
!sk2->sk_bound_dev_if ||
sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
if ((!reuse || !sk2->sk_reuse ||
sk2->sk_state == TCP_LISTEN) &&
(!reuseport || !sk2->sk_reuseport ||
(sk2->sk_state != TCP_TIME_WAIT &&
!uid_eq(uid, sock_i_uid(sk2))))) {
//只要sk和sk2两个套接字绑定的ip地址，任意一个为全零(相当于通配符)或者
//两个ip完全相等，就认为有地址冲突。
if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
break;
}
if (!relax && reuse && sk2->sk_reuse &&
sk2->sk_state != TCP_LISTEN) {
if (!sk2->sk_rcv_saddr || !sk->sk_rcv_saddr ||
sk2->sk_rcv_saddr == sk->sk_rcv_saddr)
break;
}
}
}
return sk2 != NULL;
}
接收client连接
如果有两个完全重复的套接字在监听，如下，哪个套接字接收客户端的请求呢？
root@ubuntu:/home/jk/socket# netstat -nap | grep 2222
tcp 0 0 192.168.122.1:2222 0.0.0.0:* LISTEN 46735/server1
tcp 0 0 192.168.122.1:2222 0.0.0.0:* LISTEN 46728/server
因为有多个相同的监听套接字，需要找个使用哪个套接字来处理。
客户请求首先在tcp_v4_rcv中调用__inet_lookup查找，先调用__inet_lookup_established使用四元组在已建立连接表中查找，如果是第一次请求显然找不到，接着调用__inet_lookup_listener在监听表中查找，具体代码如下：
struct sock *__inet_lookup_listener(struct net *net,
struct inet_hashinfo *hashinfo,
const __be32 saddr, __be16 sport,
const __be32 daddr, const unsigned short hnum,
const int dif)
struct sock *sk, *result;
struct hlist_nulls_node *node;
unsigned int hash = inet_lhashfn(net, hnum);
struct inet_listen_hashbucket *ilb = &hashinfo->listening_hash[hash];
int score, hiscore, matches = 0, reuseport = 0;
u32 phash = 0;
result = NULL;
hiscore = 0;
sk_nulls_for_each_rcu(sk, node, &ilb->head) {
//根据目的ip和目的端口号进行匹配。如果匹配成功则返回值大于0
//返回值就是这次匹配得到的分数，最终分数高的胜出。匹配度越高分数越高。
score = compute_score(sk, net, hnum, daddr, dif);
if (score > hiscore) {
result = sk;
hiscore = score;
//如果设置了reuseport选项
reuseport = sk->sk_reuseport;
if (reuseport) {
phash = inet_ehashfn(net, daddr, hnum, saddr, sport);
matches = 1;
}
} else if (score == hiscore && reuseport) {
matches++;
if (reciprocal_scale(phash, matches) == 0)
result = sk;
phash = next_pseudo_random32(phash);
}
}
计算分数。
三个匹配条件：sk_family ，socket绑定的本地ip rcv_saddr，socket绑定的本地接口sk_bound_dev_if。
如果目的ip和socket绑定的ip地址不同或者报文入接口和socket绑定的接口不同，则得分为-1，
说明匹配失败
如果三个都匹配，则分数为10，为最高分数。
static inline int compute_score(struct sock *sk, struct net *net,
const unsigned short hnum, const __be32 daddr,
const int dif)
{
int score = -1;
struct inet_sock *inet = inet_sk(sk);
//网络空间net必须相同，目的端口号必须和绑定的端口号相同，否则直接返回 -1
if (net_eq(sock_net(sk), net) && inet->inet_num == hnum && !ipv6_only_sock(sk)) {
__be32 rcv_saddr = inet->inet_rcv_saddr;
//sk->sk_family为PF_INET 得分为2，否则为1
score = sk->sk_family == PF_INET ? 2 : 1;
if (rcv_saddr) {
//目的ip和绑定ip不同，直接返回 -1
if (rcv_saddr != daddr)
return -1;
//目的ip和绑定ip相同，得分加4
score += 4;
}
//调用 SO_BINDTODEVICE 绑定了接口
if (sk->sk_bound_dev_if) {
//报文收接口和绑定接口不同，直接返回 -1
if (sk->sk_bound_dev_if != dif)
return -1;
//报文收接口和绑定接口相同，得分加4
score += 4;
}
}
return score;
}
举例1：server上有三个监听套接字(前两个属于ip冲突的情况，需要设置reuseaddr才能bind成功)，并且都没有绑定本地接口。
0.0.0.0:80 --对应sock1
192.168.1.2:80 --对应sock2
10.24.35.142:80 --对应sock3
如果此时client访问server: 192.168.1.2:80，则得分情况如下：
匹配到0.0.0.0时，rcv_saddr为0，所以只能 score=2
匹配到192.168.1.2时，rcv_saddr不为0，并且和请求目的ip相同，所以 socre=2+4=6
匹配到10.24.35.142时，rcv_saddr不为0，但是和请求目的ip不同，所以score=-1
所以最终返回的socket为最匹配的sock2
举例2：server上有三个监听套接字(需要设置reuseport才能bind成功)，并且都没有绑定本地接口。
server端有三个监听socket
192.168.1.2:80
192.168.1.2:80
192.168.1.2:80
当有client连接到来时，用四元组计算hash，将结果对reuseport套接字数量取模，得到一个索引，该索引指示的数组位置对应的套接字便是工作套接字。
同一条tcp流的前两个建立连接的请求syn和响应ack报文需要走上面流程，连接建立后，后续报文到来后，可直接在已建立连接表查找到。
参考
https://segmentfault.com/a/1190000020524323
https://blog.csdn.net/dog250/article/details/51510823
