從Linux源碼看Socket(TCP)的Bind

作者： alchemystarlzy 2020-10-10 07:00:16

系統 Linux

今天筆者就來從Linux源碼的角度看下Server端的Socket在進行bind的時候到底做了哪些事情(基于Linux 3.10內核)。

[[345250]]

前言

筆者一直覺得如果能知道從應用到框架再到操作系統的每一處代碼，是一件Exciting的事情。今天筆者就來從Linux源碼的角度看下Server端的Socket在進行bind的時候到底做了哪些事情(基于Linux 3.10內核)。

一個最簡單的Server端例子

眾所周知，一個Server端Socket的建立，需要socket、bind、listen、accept四個步驟。

代碼如下:

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也就是操作函數。

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的流程

值得注意的是，由于對于<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地址。對我們最直接的影響如下圖所示:

然后，我們看下一個比較復雜的函數，即可用端口號的選擇過程inet_csk_get_port

(sk->sk_prot->get_port)

inet_csk_get_port

第一段，如果bind port為0，隨機搜索可用端口號

直接上源碼，第一段代碼為端口號為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端隨機端口號。

第二段，找到端口號或已經指定

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; 
    } 
    ...... 
}

上面代碼的邏輯如下圖所示:

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));

在原生JAVA中

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

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

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狀態也可以!

這個在我們平常工作中，最常見的就是原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中判斷是否沖突的下面代碼也是為這個參數而添加的邏輯:

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

這段代碼讓我們在多次bind的時候，如果設置了SO_REUSEPORT的時候不會報錯，也就是讓我們有個多線程(進程)bind/listen的能力。如下圖所示:

而開啟了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; 
          # ... 
     } 
}