你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

SO_REUSEADDR 与 SO_REUSEPORT 是什么?

[复制链接]
gaosmile 发布时间:2021-1-18 11:16
SO_REUSEPORT 选项在Linux 3.9被引入内核,在这之前也有一个很像的选项SO_REUSEADDR。
如果你不太清楚这两者的区别和联系,建议搜索 How do SO_REUSEADDR and SO_REUSEPORT differ?。
如果不想读,那么下面这一节算是为懒人准备的。
微信图片_20210118111339.jpg
SO_REUSEADDR 与 SO_REUSEPORT 是什么?0 j# Y* b  u( k% Y2 t* h
TCP/UDP用五元组唯一标识一个连接。
任何时候,两条连接的五元组都不能完全相同,否则当收到一个报文时,协议栈没办法判断它是属于哪个连接的。

  1. * n, G  _- ~& @# {( z  J, n
  2. 五元组0 @% e: q) X4 M& m& a. a
  3. {<protocol>, <src addr>, <src port>, <dest addr>, <dest port>}
复制代码

* n7 F9 X* t8 y& h- [# c5 s
五元组里,protocol在创建socket时确定,<src addr>和<src port>在bind()时确定,<dest addr>和<dest port>在connect()时确定。
当然,bind()和connect()在一些时候并不需要显式使用,不过这不在本文的讨论范围里。
那么,如果对socket设置了SO_REUSEADDR和SO_REUSEPORT选项,它们什么时候起作用呢?
答案是bind(),也就在确定<src addr>和<src port>时。
不同操作系统内核对待SO_REUSEADDR和SO_REUSEPORT的行为有少许差异,但它们都源自BSD。
因此,接下来就以BSD的实现为标准进行说明。
SO_REUSEADDR
假设我现在需要bind()将socketA绑定到A:X,将socketB绑定到B:Y(不考虑X=0或者Y=0,因为0表示让内核自动分配端口,一定不会冲突)。
如果X!=Y,那么无论A和B的关系如何,两个bind()都会成功。但如果X==Y,那么结果会是下面这样:
SO_REUSEADDR       socketA        socketB       Result
% J: U7 U  F: D5 _---------------------------------------------------------------------  t: _! A, J. Z- O2 s! g/ u
  ON/OFF       192.168.0.1:21   192.168.0.1:21    Error (EADDRINUSE)( e  `+ }" u4 j! J
  ON/OFF       192.168.0.1:21      10.0.0.1:21    OK
5 s* z8 Y& \# _8 G: t  ?+ |  ON/OFF          10.0.0.1:21   192.168.0.1:21    OK
- b* `: B( `% h4 C0 x! t4 J   OFF             0.0.0.0:21   192.168.1.0:21    Error (EADDRINUSE)" w9 `1 O; o! ]7 x0 b; L9 e
   OFF         192.168.1.0:21       0.0.0.0:21    Error (EADDRINUSE)
9 m% S# r1 y! k4 l. j4 d3 X   ON              0.0.0.0:21   192.168.1.0:21    OK
( J6 v! H0 Z- ^7 G* B, E. D   ON          192.168.1.0:21       0.0.0.0:21    OK
4 k! U: i: T, f0 l3 S  ON/OFF           0.0.0.0:21       0.0.0.0:21    Error (EADDRINUSE)
第一列表示是否设置SO_REUSEADDR注,最后一列表示后绑定的socket是否能绑定成功。
注:这里设置的对象是指后绑定的socket(也就是说不关心前一个是否设置)
可以看出,BSD的实现中SO_REUSEADDR可以让一个使用通配地址(0.0.0.0),一个使用指定地址(192.168.1.0)的socket同时绑定成功。
SO_REUSEADDR还有一种应用情景:在TCP中存在一个TIME_WAIT状态,它是指主动关闭的一端最后停留的阶段。
假设socketA绑定到A:X,在完成TCP通信后主动使用close(),进入TIME_WAIT,此时,如果socketB也去绑定A:X,那么同样会得到 EADDRINUSE 错误,但如果socketB设置了SO_REUSEADDR,那么就可以绑定成功。
SO_REUSEPORT
如果理解了SO_REUSEADDR,那么SO_REUSEPORT就很好理解了,它让两个socket可以绑定完全相同的<IPort>。
SO_REUSEPORT       socketA        socketB       Result3 u, x  D! }& q0 |7 ^" d; S
---------------------------------------------------------------------2 @; e* b0 e: j+ H
    ON         192.168.0.1:21   192.168.0.1:21    OK
提醒一下,以上的结果都是BSD的结果,Linux内核有一些不一样的地方,具体表现为
  • 3.9版本支持SO_REUSEPORT,作为Server的TCP Socket一旦绑定到了具体的端口,启动了LISTEN,即使它之前设置过SO_REUSEADDR, 也不会生效。这一点Linux比BSD更加严格
      y" K9 r# l# U+ Y
SO_REUSEADDR       socketA        socketB       Result8 E/ i$ O1 s  t8 e
---------------------------------------------------------------------
1 a' _" e( e; D    ON/OFF      192.168.0.1:21   0.0.0.0:21    Error (EADDRINUSE)
  • 3.9版本之前,作为Client的Socket,SO_REUSEADDR选项具有BSD中的SO_REUSEPORT的效果。这一点Linux又比BSD更加宽松。

    0 x7 {' [( p3 m6 p& K. R
SO_REUSEADDR      socketA            socketB           Result
  g$ z7 C$ h+ b6 U. V/ B9 w' g; O---------------------------------------------------------------------" e* A: u5 k/ x1 Z* h
    ON        192.168.0.2:55555   192.168.0.2:55555      OK

* {: A/ x; b8 W& |6 q. s
Linux中reuseport的演进
7 A( @2 m$ ^$ [! v. V
Linux < 3.9
& w4 z3 M" V( u) L* W1 q
下面看看具体是怎么做的:   内核socket使用skc_reuse字段表示是否设置了SO_REUSEADDR

5 u/ {& u1 O. Y$ P- I" P
struct sock_common {$ h- l2 U; p5 O- I2 K- c$ H
     /* omitted */  ~! F/ }  K, j5 e' S% @
    unsigned char        skc_reuse;
% q6 `6 U4 {% |  C3 c( g  A    /* omitted */
- {7 i! n( u: Y$ X' l}
' J3 d! |7 f8 \3 D
1 u) ^2 |) q( `% n# eint sock_setsockopt(struct socket *sock, int level, int optname,...! A, \4 s2 L/ R7 S
{
0 f$ }$ y) k6 p+ i0 w# q' Y    ......
) e6 X, b& z) x; Q/ y! x$ H    case SO_REUSEADDR:8 _7 _- P/ Q, |2 z/ N
     sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);; ^4 y0 O" E9 x. G# q
     break;* G  j. [5 z+ G1 T1 z3 w/ L
}
inet_bind_bucket表示一个绑定的端口。
struct inet_bind_bucket {
; O1 W: q) Y4 w' ?    /* omitted */1 c. ?" z- j: L6 H) S2 @) T8 [
    unsigned short        port;
5 {/ q; t+ A$ W, W    signed short        fastreuse;" W. [3 k  @6 ~7 B
    int            num_owners;* ^" \+ K' W$ S3 u1 u
    struct hlist_node    node;
  R# Z) O# ~- s6 {) i& g$ k: D    struct hlist_head    owners;
3 }) b3 A# M8 k; R4 q};
上面结构中的fastreuse表示该端口是否支持共享,所有共享该端口的socket挂到owner成员上。在用户使用bind()时,内核使用TCP:inet_csk_get_port(),UDP:udp_v4_get_port()来绑定端口。
/* inet_connection_Sock.c: inet_csk_get_port() */) F$ v+ L' C1 \8 \* m' ^% }. v
tb_found:
' E9 Z/ K% L& T3 b' z) d; |    if (!hlist_empty(&tb->owners)) {
+ @6 Y9 E$ k; K        ......
; |2 O" Y) E& D; v! _        if (tb->fastreuse > 0 &&! u2 F( u0 j; ]1 G6 k2 p9 k
            sk->sk_reuse && sk->sk_state != TCP_LISTEN &&) H+ L* X! |& r( |0 ?/ \! {
            smallest_size == -1) {
* q: Q) R) [: [- y            goto success;
所以,当该端口支持共享,且socket也设置了SO_REUSEADDR并且不为LISTEN状态时,此次bind()可以成功。
3.9 =< Linux < 4.5
3.9版本内核增加了对SO_REUSEPORT的支持,listener可以绑定到相同的<IPort>了。
这个时候,当Server收到Client发送的SYN报文时,会选择其中一个socket进行响应。
具体到实现,3.9版本扩展了sock_common,将原来记录skc_reuse进行了拆分.
struct sock_common {
6 L- U1 p  Q3 d5 V8 u+ I     unsigned short        skc_family;& P9 V! ^3 p' B) a! L' _) x# L
     volatile unsigned char    skc_state;
; `' }' G; Z+ k1 Q. ]-    unsigned char        skc_reuse;7 w' o  I; K0 u& \$ Q$ z
+    unsigned char        skc_reuse:4;
& G# `4 E" c4 ]6 `$ p1 w* }+    unsigned char        skc_reuseport:4;6 a- m4 \' d( z+ @0 _& `- U
, ]8 ]2 Y& B" h1 j/ \# [7 b
* s/ m; W# E% ?, R) g
@@ int sock_setsockopt(struct socket *sock, int level, int optname,
$ B3 {# n& g7 u! P     case SO_REUSEADDR:. @& Z- g" o. b0 Z
         sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);! [1 x4 D6 B3 f8 Y  R) V( ]( g, w
         break;
9 ~/ K$ ~5 |3 R* U+    case SO_REUSEPORT:
5 a- @5 u9 y( b- V+        sk->sk_reuseport = valbool;1 g. w+ P6 D5 z5 w1 r$ n9 N. F
+        break;  r% A3 o% \. q" W
然后对inet_bind_bucket也相应进行了扩展
struct inet_bind_bucket {
0 q& @3 @- \0 F! o' Z1 X9 b     /* omitted */
. p( p( t: p& @! w: K2 J) `     unsigned short        port;: F3 u4 q8 k2 e; X- y2 D+ o" W
-    signed short        fastreuse;
: K& ]) ^1 g0 a+ z9 c6 N" l; Y7 B4 a+    signed char        fastreuse;
, A) l6 W5 A  h+    signed char        fastreuseport;- V% B& i! v- [' u1 m2 U7 P9 z
+    kuid_t            fastuid;
而在绑定端口时,增加了一个队reuseport的通过条件
/* inet_connection_sock.c: inet_csk_get_port() */
/ b" X+ P; i5 L" f# R- ~* Gtb_found:
6 B% o1 K( j6 b2 _$ V9 X         if (sk->sk_reuse == SK_FORCE_REUSE)
( S/ p% n1 f6 m  F2 Z! n             goto success;1 t# K5 c; F' V% v
-        if (tb->fastreuse > 0 &&
9 y. q6 k+ v) K, O. j0 [-            sk->sk_reuse && sk->sk_state != TCP_LISTEN &&
  I4 \" V) L6 f+ E3 i9 Z+        if (((tb->fastreuse > 0 &&. \4 ^- d, ?; x$ W; o) ]: I9 b2 q
+              sk->sk_reuse && sk->sk_state != TCP_LISTEN) ||6 p; O# q+ D; r8 X. [0 N
+             (tb->fastreuseport > 0 &&- ?- y5 x8 l6 \5 z) I. U0 F9 S: m4 A
+              sk->sk_reuseport && uid_eq(tb->fastuid, uid))) ' m1 k! W, h8 }; ]
             && smallest_size == -1) {. f9 u+ `7 |# \, G, C/ I
               goto success;
而当Client的SYN报文到达时,Server会首先根据本地端口(SYN报文的<dport>)计算出一条hash冲突链,然后遍历该链表上的所有Socket,根据四元组匹配程度进行打分;
如果使能了reuseport,那么可能有多个Socket都将拿到最高分,此时内核将随机选择一个进行后续处理。
/* inet_hashtables.c  */# c% a$ r$ C. ^, M9 t& h# j
struct sock *__inet_lookup_listener(struct......)
5 E" V/ v- i! k( |{, D, _/ `( O3 a( N& N7 E3 X) u
    struct sock *sk, *result;; B( C, A( b  H  T- {, l
    unsigned int hash = inet_lhashfn(net, hnum);
9 g8 N1 D' r9 R" L4 s4 ^    struct inet_listen_hashbucket *ilb = &hashinfo->listening_hash[hash]; // 根据本地端口找到hash冲突链4 F9 e) Q% n( A- Y+ _
    /* code omitted */
" ]! T8 P" R9 L* @0 ^7 E* Z! y# d    result = NULL;; X# |$ W! k/ T3 }+ x
    hiscore = 0;
' V3 Q0 R) H2 D& x    sk_nulls_for_each_rcu(sk, node, &ilb->head) {
, R/ a& ^1 y/ v1 o$ Q        score = compute_score(sk, net, hnum, daddr, dif); // 根据匹配程度进行打分: s: D8 x: c6 \4 F! U5 s& |
        if (score > hiscore) {* h6 {: z8 D. Z8 e
            result = sk;4 k0 t: p4 x1 k7 a9 ~
            hiscore = score;9 F" F) Z2 B0 x# N
            reuseport = sk->sk_reuseport;( k$ P5 l7 R" D3 z' E, P8 Y  e; g( {
            if (reuseport) {
9 C' L) `" u+ p6 T5 G& ?                phash = inet_ehashfn(net, daddr, hnum,
+ ^/ ~# k4 M+ Q* q* A" g" d                             saddr, sport);
9 E/ H+ [& G' }3 s                matches = 1;                             // 如果是reuseport 则累计多少个socket满足4 Y0 w- C3 i* ~# S8 v- M
            }
3 ~8 g- q, {& i        } else if (score == hiscore && reuseport) {
- L* i% o9 |4 d0 i4 p  p            matches++;; u5 g" A4 ~! B5 ?5 F4 u
            if (reciprocal_scale(phash, matches) == 0)( z0 o4 B+ F! d  z1 G- F
                result = sk;
  ]: ~8 g7 B# }            phash = next_pseudo_random32(phash);. q9 h" \% }9 \- Y: A: M
        }
% c; L( g, d: L/ i0 B/ R) s    }
$ n" w; B1 T' A+ s( r    /*
% j4 I% n0 y/ z     * if the nulls value we got at the end of this lookup is8 N5 w3 L' s3 v6 S3 p) d+ W
     * not the expected one, we must restart lookup.. |- n6 {7 |; V( _
     * We probably met an item that was moved to another chain.
+ k9 p4 p% Y  O5 b     */. g6 k: M- o  M+ n/ j8 j
    return result;
) f% M/ l, i( T2 G9 H4 f9 I5 Z}
举个栗子,假设内核有4条listening socket的hash冲突链,然后用户建立了4个Server:A、B、C、D,监听的地址和端口如下图所示,A和B使能了SO_REUSEPORT。
冲突链是以端口为Key的,因此A、B、D会挂到同一条冲突链上。
如果此时收到对端一个SYN报文<192.168.10.1, 21>,那么内核会遍历listening_hash[0],为上面的7个socket进行打分,而由于B监听的是精确的地址,所以B的得分会比A高,内核最终选择出一个SocketB进行后续处理。
微信图片_20210118111343.png
4.5 < Linux
从上面的例子可以看出,当收到SYN报文时,内核一定会遍历一条完整hash冲突链,为每一个socket进行打分,这稍微有些多余。
因此,在4.5版本中,内核引入了reuseport groups,它将绑定到同一个IP和Port,并且设置了SO_REUSEPORT选项的socket组织到一个group内部。
微信图片_20210118111346.png
--- a/include/net/sock.h
) @: G4 {* j+ z! F3 e+++ b/include/net/sock.h
9 Q  g" _/ E( ?* Q@@ -318,6 +318,7 @@ struct cg_proto;
/ A* f- Y0 \, O  {" }+ I   *    @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)0 n* H7 B& Z1 ~  T6 M
   *    @sk_backlog_rcv: callback to process the backlog/ |8 l8 n$ Z- M, R
   *    @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0' H. R4 a8 M1 F+ P- ^
+  *    @sk_reuseport_cb: reuseport group container
4 B0 z8 S3 [' ]2 d9 v! B7 O1 m( [  */
+ Y; o' {1 h- _ struct sock {
6 q: U$ h; e3 j5 F! z" I3 U     /*6 e2 o  q6 s8 F& M" ]* |
@@ -453,6 +454,7 @@ struct sock {8 K8 Q1 Y5 w- c* T3 i* ]
     int            (*sk_backlog_rcv)(struct sock *sk,9 e$ o( J% v! J, _3 b! T
                           struct sk_buff *skb);& |9 |( D7 A. q' ]0 _
     void                    (*sk_destruct)(struct sock *sk);
+ P" S* f0 g* l+    struct sock_reuseport __rcu    *sk_reuseport_cb;: k! x" J# b' u* m( x' e5 p$ p
};
这个特性在4.5版本只支持UDP,而在4.6版本开始支持TCP(patch)。
这样在查找listen socket时,内核将不用再遍历整个冲突链,而是在找到一个合格的socket时,如果它设置了SO_REUSEPORT,就直接找到它所属的reuseport group,从中选择一个进行后续处理。
@@ -215,6 +217,7 @@ struct sock *__inet_lookup_listener(struct net *net,
( [  I# t! i, ^, D3 U  L: {     unsigned int hash = inet_lhashfn(net, hnum);
$ s; n' W9 M! y: ?4 Y     struct inet_listen_hashbucket *ilb = &hashinfo->listening_hash[hash];
" z& A0 }9 {3 d* R5 c, z- Y: a4 u     int score, hiscore, matches = 0, reuseport = 0;
$ Q/ ^1 j" _6 U: r) D+    bool select_ok = true;) x: O* j$ `3 B7 |9 C/ V  X
     u32 phash = 0;" S6 g* Z) o; w

5 c1 t: c' w; D2 L) b; h8 ?     rcu_read_lock();
; B% {# |* F) f5 E2 @$ Y@@ -230,6 +233,15 @@ begin:7 H0 A: W2 q5 H
             if (reuseport) {8 b0 s( U% d3 w
                 phash = inet_ehashfn(net, daddr, hnum,( v$ i8 S3 k& ]/ w" f
                              saddr, sport);
2 `# K' S  ~- Z9 F* n" O3 {+                if (select_ok) {# C0 r* O6 I$ M
+                    struct sock *sk2;
9 i+ m% w* K6 ?% s+                    sk2 = reuseport_select_sock(sk, phash,
% @) f- ?: e* \# N7 v: p9 W1 D+                                    skb, doff);, C- u4 s) z) y% B9 {
+                    if (sk2) {8 D* d+ T1 d( v, G/ ^4 a
+                        result = sk2;
4 Z/ K. t3 g. j! M4 g& R- ~+                        goto found;2 W2 [& r1 a. j8 K; g. C5 L0 C8 C
+                    }- E/ H' \9 B- p+ r* \
+                }4 E, r* O5 v2 n+ g1 l
                 matches = 1;4 S; e) u0 |3 T7 L
             }
& a, O; h2 b5 G8 b4 j" f& ^, B         }

' q+ w( R! W, Z" l0 v8 w4 M- @
赞 收藏 评论0 发布时间:2021-1-18 11:16

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版