从Linux源码看Socket(TCP)的bind

浅浅的花香味﹌ 2022-12-19 08:59 143阅读 0赞

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

**一个最简单的Server端例子**

众所周知，一个Server端Socket的建立，需要socket、bind、listen、accept四个步骤。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]

代码如下:

void start_server(){ 
        // server fd
        int sockfd_server;
        // accept fd 
        int sockfd;
        int call_err;
        struct sockaddr_in sock_addr;
    
        sockfd_server = socket(AF_INET,SOCK_STREAM,0);
        memset(&sock_addr,0,sizeof(sock_addr));
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        sock_addr.sin_port = htons(SERVER_PORT);
        // 这边就是我们今天的聚焦点bind
        call_err=bind(sockfd_server,(struct sockaddr*)(&sock_addr),sizeof(sock_addr));
        if(call_err == -1){ 
            fprintf(stdout,"bind error!\n");
            exit(1);
        }
        // listen
        call_err=listen(sockfd_server,MAX_BACK_LOG);
        if(call_err == -1){ 
            fprintf(stdout,"listen error!\n");
            exit(1);
        }
    }

首先我们通过socket系统调用创建了一个socket，其中指定了SOCK\_STREAM,而且最后一个参数为0，也就是建立了一个通常所有的TCP Socket。在这里，我们直接给出TCP Socket所对应的ops也就是操作函数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]  
**bind系统调用**

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

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

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

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

**inet\_bind**

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

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

让我们看下inet\_bind的流程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]  
值得注意的是，由于对于<1024的端口号需要CAP\_NET\_BIND\_SERVICE,我们在监听80端口号(例如启动nginx时候),需要使用root用户或者赋予这个可执行文件CAP\_NET\_BIND\_SERVICE权限。

use root 
     or
    setcap cap_net_bind_service=+eip ./nginx

我们的bind允许绑定到0.0.0.0即INADDR\_ANY这个地址上(一般都用这个)，它意味着内核去选择IP地址。对我们最直接的影响如下图所示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]  
然后，我们看下一个比较复杂的函数，即可用端口号的选择过程inet\_csk\_get\_port (sk->sk\_prot->get\_port)

inet\_csk\_get\_port  
第一段，如果bind port为0，随机搜索可用端口号

**需要C/C++ Linux服务器架构师学习资料私信“资料”（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]

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

// 这边如果snum指定为0，则随机选择端口
    int inet_csk_get_port(struct sock *sk, unsigned short snum)
    { 
    	......
    	// 这边net_random()采用prandom_u32,是伪(pseudo)随机数
    	smallest_rover = rover = net_random() % remaining + low;
    	smallest_size = -1;
    	// snum=0,随机选择端口的分支
    	if(!sum){ 
    		// 获取内核设置的端口号范围,对应内核参数/proc/sys/net/ipv4/ip_local_port_range 
    		inet_get_local_port_range(&low,&high);
    		......
    		do{ 
    			if(inet_is_reserved_local_port(rover)
    				goto next_nonlock; // 不选择保留端口号
    			......
    			inet_bind_bucket_for_each(tb, &head->chain)
    				// 在同一个网络命名空间下存在和当前希望选择的port rover一样的port
    				if (net_eq(ib_net(tb), net) && tb->port == rover) { 
    					// 已经存在的sock和当前新sock都开启了SO_REUSEADDR,且当前sock状态不为listen
    					// 或者
    					// 已经存在的sock和当前新sock都开启了SO_REUSEPORT,而且两者都是同一个用户
    					if (((tb->fastreuse > 0 &&
    					      sk->sk_reuse &&
    					      sk->sk_state != TCP_LISTEN) ||
    					     (tb->fastreuseport > 0 &&
    					      sk->sk_reuseport &&
    					      uid_eq(tb->fastuid, uid))) &&
    					    (tb->num_owners < smallest_size || smallest_size == -1)) { 
    					   // 这边是选择一个最小的num_owners的port，即同时bind或者listen最小个数的port
    					   // 因为一个端口号(port)在开启了so_reuseaddr/so_reuseport之后，是可以多个进程同时使用的
    						smallest_size = tb->num_owners;
    						smallest_rover = rover;
    						if (atomic_read(&hashinfo->bsockets) > (high - low) + 1 &&
    						    !inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) { 
    						    // 进入这个分支，表明可用端口号已经不够了，同时绑定当前端口号和之前已经使用此port的不冲突，则我们选择这个端口号(最小的)
    							snum = smallest_rover;
    							goto tb_found;
    						}
    					}
    					// 若端口号不冲突，则选择这个端口
    					if (!inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, false)) { 
    						snum = rover;
    						goto tb_found;
    					}
    					goto next;
    				}
    			break;
    			// 直至遍历完所有的可用port
    		} while (--remaining > 0);
    	}
    	.......
    }

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

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

```cpp
    have_snum:
    	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:
    	// 如果此port已被bind
    	if (!hlist_empty(&tb->owners)) { 
    		// 如果设置为强制重用，则直接成功
    		if (sk->sk_reuse == SK_FORCE_REUSE)
    			goto success;
    	}
    	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) { 
    		    // 这个分支表明之前bind的port和当前sock都设置了reuse同时当前sock状态不为listen
    			// 或者同时设置了reuseport而且是同一个uid(注意，设置了reuseport后，可以同时listen同一个port了)
    			goto success;
    	} else { 
    			ret = 1;
    			// 检查端口是否冲突
    			if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb, true)) { 
    				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) { 
    				    // 若冲突，但是设置了reuse非listen状态或者设置了reuseport且出在同一个用户下
    				    // 则可以进行重试
    					spin_unlock(&head->lock);
    					goto again;
    				}
    
    				goto fail_unlock;
    			}
    			// 不冲突，走下面的逻辑
    		}
    tb_not_found:
    	if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,
    					net, head, snum)) == NULL)
    			goto fail_unlock;
    	// 设置fastreuse
    	// 设置fastreuseport
    success:
    	......
    	// 将当前sock链入tb->owner，同时tb->num_owners++
    	inet_bind_hash(sk, tb, snum);
    	ret = 0;
    	// 返回bind(绑定)成功
    	return ret;

**判断端口号是否冲突**

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

inet_csk(sk)->icsk_af_ops->bind_conflict 也即 inet_csk_bind_conflict
    int inet_csk_bind_conflict(const struct sock *sk,
    			   const struct inet_bind_bucket *tb, bool relax){ 
    	......
    	sk_for_each_bound(sk2, &tb->owners) { 
    			// 这边判断表明，必须同一个接口(dev_if)才进入下内部分支，也就是说不在同一个接口端口的不冲突
    			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))))) { 
    			   // 在有一方没设置reuse且sock2状态为listen 同时
    			   // 有一方没设置reuseport且sock2状态不为time_wait同时两者的uid不一样的时候
    				const __be32 sk2_rcv_saddr = sk_rcv_saddr(sk2);
    				if (!sk2_rcv_saddr || !sk_rcv_saddr(sk) ||
    				 	 // ip地址一样，才算冲突
    				    sk2_rcv_saddr == sk_rcv_saddr(sk))
    					break;
    			}
    			// 非放松模式，ip地址一样，才算冲突
    			......
    		  	return sk2 != NULL;
    	}
    	......
    }

上面代码的逻辑如下图所示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]

**SO\_REUSEADDR和SO\_REUSEPORT**

上面的代码有点绕，笔者就讲一下，对于我们日常开发要关心什么。 我们在上面的bind里面经常见到sk\_reuse和sk\_reuseport这两个socket的Flag。这两个Flag能够决定是否能够bind(绑定)成功。这两个Flag的设置在C语言里面如下代码所示:

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

**SO\_REUSEADDR**

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

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

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

我们可以得出，如果原sock和新sock都设置了SO\_REUSEADDR的时候，只要原sock不是Listen状态，都可以绑定成功，甚至ESTABLISHED状态也可以!  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]  
这个在我们平常工作中，最常见的就是原sock处于TIME\_WAIT状态，这通常在我们关闭Server的时候出现，如果不设置SO\_REUSEADDR,则会绑定失败，进而启动不来服务。而设置了SO\_REUSEADDR,由于不是TCP\_LISTEN,所以可以成功。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 7]  
这个特性在紧急重启以及线下调试的非常有用，建议开启。

**SO\_REUSEPORT**

SO\_REUSEPORT是Linux在3.9版本引入的新功能。

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

我们看下一般的Reactor线程模型，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 8]

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

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

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

这段代码让我们在多次bind的时候，如果设置了SO\_REUSEPORT的时候不会报错，也就是让我们有个多线程(进程)bind/listen的能力。如下图所示:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 9]  
而开启了SO\_REUSEPORT后，代码栈如下:

tcp_v4_rcv
    	|->__inet_lookup_skb 
    		|->__inet_lookup
    			|->__inet_lookup_listener
     /* 用打分和伪随机数等挑选出一个listen的sock */
    struct sock *__inet_lookup_listener(......)
    { 
    	......
    	if (score > hiscore) { 
    			result = sk;
    			hiscore = score;
    			reuseport = sk->sk_reuseport;
    			if (reuseport) { 
    				phash = inet_ehashfn(net, daddr, hnum,
    						     saddr, sport);
    				matches = 1;
    			}
    		} else if (score == hiscore && reuseport) { 
    			matches++;
    			if (((u64)phash * matches) >> 32 == 0)
    				result = sk;
    			phash = next_pseudo_random32(phash);
    		}
    	......
    }

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

**Nginx已经采用SO\_REUSEPORT**

Nginx在1.9.1版本的时候引入了SO\_REUSEPORT，配置如下:

http { 
         server { 
              listen 80 reuseport;
              server_name  localhost;
              # ...
         }
    }
    
    stream { 
         server { 
              listen 12345 reuseport;
              # ...
         }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 10]  
![在这里插入图片描述][20201106151412544.png_pic_center]

在压测场景下，性能提升了3倍！

**总结**

Linux内核源码博大精深，一个看起来简单的bind系统调用竟然牵涉这么多，在里面可以挖掘出各种细节。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/69266608a46f44f0835b9d8e6f41bfdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201106150428785.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201106150620857.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201106150649743.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201106151548425.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201106150851847.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/202011061511195.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201106151136152.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201106151220853.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 9]: https://img-blog.csdnimg.cn/2020110615131978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 10]: https://img-blog.csdnimg.cn/20201106151404668.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[20201106151412544.png_pic_center]: https://img-blog.csdnimg.cn/20201106151412544.png#pic_center