从Linux源码看Socket(TCP)的Bind

系统 Linux
今天笔者就来从Linux源码的角度看下Server端的Socket在进行bind的时候到底做了哪些事情(基于Linux 3.10内核)。

[[345250]]

前言

笔者一直觉得如果能知道从应用到框架再到操作系统的每一处代码,是一件Exciting的事情。今天笔者就来从Linux源码的角度看下Server端的Socket在进行bind的时候到底做了哪些事情(基于Linux 3.10内核)。

一个最简单的Server端例子

众所周知,一个Server端Socket的建立,需要socket、bind、listen、accept四个步骤。

 

代码如下:

  1. void start_server(){ 
  2.     // server fd 
  3.     int sockfd_server; 
  4.     // accept fd 
  5.     int sockfd; 
  6.     int call_err; 
  7.     struct sockaddr_in sock_addr; 
  8.  
  9.     sockfd_server = socket(AF_INET,SOCK_STREAM,0); 
  10.     memset(&sock_addr,0,sizeof(sock_addr)); 
  11.     sock_addr.sin_family = AF_INET; 
  12.     sock_addr.sin_addr.s_addr = htonl(INADDR_ANY); 
  13.     sock_addr.sin_port = htons(SERVER_PORT); 
  14.     // 这边就是我们今天的聚焦点bind 
  15.     call_err=bind(sockfd_server,(struct sockaddr*)(&sock_addr),sizeof(sock_addr)); 
  16.     if(call_err == -1){ 
  17.         fprintf(stdout,"bind error!\n"); 
  18.         exit(1); 
  19.     } 
  20.     // listen 
  21.     call_err=listen(sockfd_server,MAX_BACK_LOG); 
  22.     if(call_err == -1){ 
  23.         fprintf(stdout,"listen error!\n"); 
  24.         exit(1); 
  25.     } 

首先我们通过socket系统调用创建了一个socket,其中指定了SOCK_STREAM,而且最后一个参数为0,也就是建立了一个通常所有的TCP Socket。在这里,我们直接给出TCP Socket所对应的ops也就是操作函数。

bind系统调用

bind将一个本地协议地址(protocol:ip:port)赋予一个套接字。例如32位的ipv4地址或128位的ipv6地址+16位的TCP或UDP端口号。

  1. #include <sys/socket.h> 
  2. // 返回,若成功则为0,若出错则为-1 
  3. int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); 

好了,我们直接进入Linux源码调用栈吧。

 

  1. bind 
  2.     // 这边由系统调用的返回值会被glibc的INLINE_SYSCALL包一层 
  3.     // 若有错误,则设置返回值为-1,同时将系统调用的返回值的绝对值设置给errno 
  4.     |->INLINE_SYSCALL (bind......); 
  5.         |->SYSCALL_DEFINE3(bind......); 
  6.             /* 检测对应的描述符fd是否存在,不存在,返回-BADF 
  7.             |->sockfd_lookup_light 
  8.             |->sock->ops->bind(inet_stream_ops) 
  9.                 |->inet_bind 
  10.                     |->AF_INET兼容性检查 
  11.                     |-><1024端口权限检查 
  12.                     /* bind端口号校验or选择(在bind为0的时候) 
  13.                     |->sk->sk_prot->get_port(inet_csk_get_port) 

inet_bind

inet_bind这个函数主要做了两个操作,一是检测是否允许bind,而是获取可用的端口号。这边值得注意的是。如果我们设置需要bind的端口号为0,那么Kernel会帮我们随机选择一个可用的端口号来进行bind!

  1. // 让系统随机选择可用端口号 
  2. sock_addr.sin_port = 0; 
  3. call_err=bind(sockfd_server,(struct sockaddr*)(&sock_addr),sizeof(sock_addr)); 

让我们看下inet_bind的流程

 

值得注意的是,由于对于<1024的端口号需要CAP_NET_BIND_SERVICE,我们在监听80端口号(例如启动nginx时候),需要使用root用户或者赋予这个可执行文件CAP_NET_BIND_SERVICE权限。

  1. use root 
  2.  or 
  3. setcap cap_net_bind_service=+eip ./nginx 

我们的bind允许绑定到0.0.0.0即INADDR_ANY这个地址上(一般都用这个),它意味着内核去选择IP地址。对我们最直接的影响如下图所示:

 


 

 

然后,我们看下一个比较复杂的函数,即可用端口号的选择过程inet_csk_get_port

(sk->sk_prot->get_port)

inet_csk_get_port

第一段,如果bind port为0,随机搜索可用端口号

直接上源码,第一段代码为端口号为0的搜索过程

  1. // 这边如果snum指定为0,则随机选择端口 
  2. int inet_csk_get_port(struct sock *sk, unsigned short snum) 
  3.     ...... 
  4.     // 这边net_random()采用prandom_u32,是伪(pseudo)随机数 
  5.     smallest_rover = rover = net_random() % remaining + low; 
  6.     smallest_size = -1; 
  7.     // snum=0,随机选择端口的分支 
  8.     if(!sum){ 
  9.         // 获取内核设置的端口号范围,对应内核参数/proc/sys/net/ipv4/ip_local_port_range 
  10.         inet_get_local_port_range(&low,&high); 
  11.         ...... 
  12.         do{ 
  13.             if(inet_is_reserved_local_port(rover) 
  14.                 goto next_nonlock; // 不选择保留端口号 
  15.             ...... 
  16.             inet_bind_bucket_for_each(tb, &head->chain) 
  17.                 // 在同一个网络命名空间下存在和当前希望选择的port rover一样的port 
  18.                 if (net_eq(ib_net(tb), net) && tb->port == rover) { 
  19.                     // 已经存在的sock和当前新sock都开启了SO_REUSEADDR,且当前sock状态不为listen 
  20.                     // 或者 
  21.                     // 已经存在的sock和当前新sock都开启了SO_REUSEPORT,而且两者都是同一个用户 
  22.                     if (((tb->fastreuse > 0 && 
  23.                           sk->sk_reuse && 
  24.                           sk->sk_state != TCP_LISTEN) || 
  25.                          (tb->fastreuseport > 0 && 
  26.                           sk->sk_reuseport && 
  27.                           uid_eq(tb->fastuid, uid))) && 
  28.                         (tb->num_owners < smallest_size || smallest_size == -1)) { 
  29.                        // 这边是选择一个最小的num_owners的port,即同时bind或者listen最小个数的port 
  30.                        // 因为一个端口号(port)在开启了so_reuseaddr/so_reuseport之后,是可以多个进程同时使用的 
  31.                         smallest_size = tb->num_owners; 
  32.                         smallest_rover = rover; 
  33.                         if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 && 
  34.                             !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) { 
  35.                             // 进入这个分支,表明可用端口号已经不够了,同时绑定当前端口号和之前已经使用此port的不冲突,则我们选择这个端口号(最小的) 
  36.                             snum = smallest_rover; 
  37.                             goto tb_found; 
  38.                         } 
  39.                     } 
  40.                     // 若端口号不冲突,则选择这个端口 
  41.                     if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) { 
  42.                         snum = rover; 
  43.                         goto tb_found; 
  44.                     } 
  45.                     goto next
  46.                 } 
  47.             break; 
  48.             // 直至遍历完所有的可用port 
  49.         } while (--remaining > 0); 
  50.     } 
  51.     ....... 

由于,我们在使用bind的时候很少随机端口号(在TCP服务器来说尤其如此),这段代码笔者就注释一下。一般只有一些特殊的远程过程调用(RPC)中会使用随机Server端随机端口号。

第二段,找到端口号或已经指定

  1. have_snum: 
  2.     inet_bind_bucket_for_each(tb, &head->chain) 
  3.             if (net_eq(ib_net(tb), net) && tb->port == snum) 
  4.                 goto tb_found; 
  5.     } 
  6.     tb = NULL
  7.     goto tb_not_found 
  8. tb_found: 
  9.     // 如果此port已被bind 
  10.     if (!hlist_empty(&tb->owners)) { 
  11.         // 如果设置为强制重用,则直接成功 
  12.         if (sk->sk_reuse == SK_FORCE_REUSE) 
  13.             goto success; 
  14.     } 
  15.     if (((tb->fastreuse > 0 && 
  16.               sk->sk_reuse && sk->sk_state != TCP_LISTEN) || 
  17.              (tb->fastreuseport > 0 && 
  18.               sk->sk_reuseport && uid_eq(tb->fastuid, uid))) && 
  19.             smallest_size == -1) { 
  20.             // 这个分支表明之前bind的port和当前sock都设置了reuse同时当前sock状态不为listen 
  21.             // 或者同时设置了reuseport而且是同一个uid(注意,设置了reuseport后,可以同时listen同一个port了) 
  22.             goto success; 
  23.     } else { 
  24.             ret = 1; 
  25.             // 检查端口是否冲突 
  26.             if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) { 
  27.                 if (((sk->sk_reuse && sk->sk_state != TCP_LISTEN) || 
  28.                      (tb->fastreuseport > 0 && 
  29.                       sk->sk_reuseport && uid_eq(tb->fastuid, uid))) && 
  30.                     smallest_size != -1 && --attempts >= 0) { 
  31.                     // 若冲突,但是设置了reuse非listen状态或者设置了reuseport且出在同一个用户下 
  32.                     // 则可以进行重试 
  33.                     spin_unlock(&head->lock); 
  34.                     goto again; 
  35.                 } 
  36.  
  37.                 goto fail_unlock; 
  38.             } 
  39.             // 不冲突,走下面的逻辑 
  40.         } 
  41. tb_not_found: 
  42.     if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep, 
  43.                     net, head, snum)) == NULL
  44.             goto fail_unlock; 
  45.     // 设置fastreuse 
  46.     // 设置fastreuseport 
  47. success: 
  48.     ...... 
  49.     // 将当前sock链入tb->owner,同时tb->num_owners++ 
  50.     inet_bind_hash(sk, tb, snum); 
  51.     ret = 0; 
  52.     // 返回bind(绑定)成功 
  53.     return ret; 

判断端口号是否冲突

在上述源码中,判断端口号时否冲突的代码为

  1. inet_csk(sk)->icsk_af_ops->bind_conflict 也即 inet_csk_bind_conflict 
  2. int inet_csk_bind_conflict(const struct sock *sk, 
  3.                const struct inet_bind_bucket *tb, bool relax){ 
  4.     ...... 
  5.     sk_for_each_bound(sk2, &tb->owners) { 
  6.             // 这边判断表明,必须同一个接口(dev_if)才进入下内部分支,也就是说不在同一个接口端口的不冲突 
  7.             if (sk != sk2 && 
  8.             !inet_v6_ipv6only(sk2) && 
  9.             (!sk->sk_bound_dev_if || 
  10.              !sk2->sk_bound_dev_if || 
  11.              sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) 
  12.              { 
  13.                  if ((!reuse || !sk2->sk_reuse || 
  14.                 sk2->sk_state == TCP_LISTEN) && 
  15.                 (!reuseport || !sk2->sk_reuseport || 
  16.                 (sk2->sk_state != TCP_TIME_WAIT && 
  17.                  !uid_eq(uid, sock_i_uid(sk2))))) { 
  18.                // 在有一方没设置reuse且sock2状态为listen 同时 
  19.                // 有一方没设置reuseport且sock2状态不为time_wait同时两者的uid不一样的时候 
  20.                 const __be32 sk2_rcv_saddr = sk_rcv_saddr(sk2); 
  21.                 if (!sk2_rcv_saddr || !sk_rcv_saddr(sk) || 
  22.                       // ip地址一样,才算冲突 
  23.                     sk2_rcv_saddr == sk_rcv_saddr(sk)) 
  24.                     break; 
  25.             } 
  26.             // 非放松模式,ip地址一样,才算冲突 
  27.             ...... 
  28.               return sk2 != NULL
  29.     } 
  30.     ...... 

上面代码的逻辑如下图所示:

 


 

 

SO_REUSEADDR和SO_REUSEPORT

上面的代码有点绕,笔者就讲一下,对于我们日常开发要关心什么。

我们在上面的bind里面经常见到sk_reuse和sk_reuseport这两个socket的Flag。这两个Flag能够决定是否能够bind(绑定)成功。这两个Flag的设置在C语言里面如下代码所示:

  1. setsockopt(sockfd_server, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int)); 
  2. setsockopt(sockfd_server, SOL_SOCKET, SO_REUSEPORT, &(int){ 1 }, sizeof(int)); 

在原生JAVA中

  1. // java8中,原生的socket并不支持so_reuseport 
  2.  ServerSocket server = new ServerSocket(port); 
  3.  server.setReuseAddress(true); 

在Netty(Netty版本 >= 4.0.16且Linux内核版本>=3.9以上)中,可以使用SO_REUSEPORT。

SO_REUSEADDR

在之前的源码里面,我们看到判断bind是否冲突的时候,有这么一个分支

  1. (!reuse || !sk2->sk_reuse || 
  2.                 sk2->sk_state == TCP_LISTEN) /* 暂忽略reuseport */){ 
  3.     // 即有一方没有设置 

如果sk2(即已bind的socket)是TCP_LISTEN状态或者,sk2和新sk两者都没有设置_REUSEADDR的时候,可以判断为冲突。

我们可以得出,如果原sock和新sock都设置了SO_REUSEADDR的时候,只要原sock不是Listen状态,都可以绑定成功,甚至ESTABLISHED状态也可以!

 

 


 

 

这个在我们平常工作中,最常见的就是原sock处于TIME_WAIT状态,这通常在我们关闭Server的时候出现,如果不设置SO_REUSEADDR,则会绑定失败,进而启动不来服务。而设置了SO_REUSEADDR,由于不是TCP_LISTEN,所以可以成功。

 

这个特性在紧急重启以及线下调试的非常有用,建议开启。

SO_REUSEPORT

SO_REUSEPORT是Linux在3.9版本引入的新功能。

1.在海量高并发连接的创建时候,由于正常的模型是单线程listener分发,无法利用多核优势,这就会成为瓶颈。

2.CPU缓存行丢失

我们看下一般的Reactor线程模型,

 


 

 

明显的其单线程listen/accept会存在瓶颈(如果采用多线程epoll accept,则会惊群,加WQ_FLAG_EXCLUSIVE可以解决一部分),尤其是在采用短链接的情况下。

鉴于此,Linux增加了SO_REUSEPORT,而之前bind中判断是否冲突的下面代码也是为这个参数而添加的逻辑:

  1. if(!reuseport || !sk2->sk_reuseport || 
  2.                 (sk2->sk_state != TCP_TIME_WAIT && 
  3.                  !uid_eq(uid, sock_i_uid(sk2)) 

这段代码让我们在多次bind的时候,如果设置了SO_REUSEPORT的时候不会报错,也就是让我们有个多线程(进程)bind/listen的能力。如下图所示:

 

而开启了SO_REUSEPORT后,代码栈如下:

  1. tcp_v4_rcv 
  2.     |->__inet_lookup_skb 
  3.         |->__inet_lookup 
  4.             |->__inet_lookup_listener 
  5.  /* 用打分和伪随机数等挑选出一个listen的sock */ 
  6. struct sock *__inet_lookup_listener(......) 
  7.     ...... 
  8.     if (score > hiscore) { 
  9.             result = sk; 
  10.             hiscore = score; 
  11.             reuseport = sk->sk_reuseport; 
  12.             if (reuseport) { 
  13.                 phash = inet_ehashfn(net, daddr, hnum, 
  14.                              saddr, sport); 
  15.                 matches = 1; 
  16.             } 
  17.         } else if (score == hiscore && reuseport) { 
  18.             matches++; 
  19.             if (((u64)phash * matches) >> 32 == 0) 
  20.                 result = sk; 
  21.             phash = next_pseudo_random32(phash); 
  22.         } 
  23.     ...... 

直接在内核层面做负载均衡,将accept的任务分散到不同的线程的不同socket上(Sharding),毫无疑问可以多核能力,大幅提升连接成功后的socket分发能力。

Nginx已经采用SO_REUSEPORT

Nginx在1.9.1版本的时候引入了SO_REUSEPORT,配置如下:

  1. http { 
  2.      server { 
  3.           listen 80 reuseport; 
  4.           server_name  localhost; 
  5.           # ... 
  6.      } 
  7.  
  8. stream { 
  9.      server { 
  10.           listen 12345 reuseport; 
  11.           # ... 
  12.      } 

 

 


 

总结

Linux内核源码博大精深,一个看起来简单的bind系统调用竟然牵涉这么多,在里面可以挖掘出各种细节。在此分享出来,希望对读者有所帮助。

本文转载自微信公众号「解Bug之路」,可以通过以下二维码关注。转载本文请联系解Bug之路公众号。

【编辑推荐】

【责任编辑:武晓燕 TEL:(010)68476606】

 

责任编辑:武晓燕 来源: 解Bug之路
相关推荐

2021-06-10 09:52:33

LinuxTCPAccept

2020-10-14 14:31:37

LinuxTCP连接

2021-07-15 14:27:47

LinuxSocketClose

2021-07-14 09:48:15

Linux源码Epoll

2010-01-21 11:19:44

TCP Socketlinux

2021-03-10 08:20:54

设计模式OkHttp

2017-04-05 20:00:32

ChromeObjectJS代码

2015-05-28 10:34:16

TCPsocket

2018-02-02 15:48:47

ChromeDNS解析

2012-03-19 11:41:30

JavaSocket

2009-08-28 14:15:19

SocketVisual C#.N

2017-02-09 15:15:54

Chrome浏览器

2020-09-23 12:32:18

网络IOMySQL

2022-03-08 11:29:06

Linux进程系统

2011-01-18 13:42:18

Linuxsocket性能

2020-09-07 14:30:37

JUC源码CAS

2021-05-06 14:46:18

LinuxIcmpudp

2019-02-17 10:05:24

TCPSocket网络编程

2023-03-13 07:43:51

PHP类型转换

2017-02-28 10:05:56

Chrome源码
点赞
收藏

51CTO技术栈公众号