TCP层bind系统调用的实现分析

说明：该文章中部分代码未能完全理解透彻，可能对您造成误解，请慎读；

并建议您先阅读本博另外一篇文章：<Linux TCP套接字选项之 SO_REUSEADDR && SO_REUSEPORT>

另：该文章将会持续更新改进；

TCP的接口绑定通过函数inet_csk_get_port函数执行，其中包含了未设置端口号自动分配的情况，设置了地址重用标记(SO_REUSEADDR)和设置了端口重用(SO_REUSEPORT)选项的处理；检查成功则控制块节点加入到绑定接口hash中对应端口的链表中；

  1 /* Obtain a reference to a local port for the given sock,
  2  * if snum is zero it means select any available local port.
  3  * We try to allocate an odd port (and leave even ports for connect())
  4  */
  5 /* 绑定端口bind */
  6 /* 下面的重用地址表示SO_REUSEADDR，重用端口表示SO_REUSEPORT */
  7 int inet_csk_get_port(struct sock *sk, unsigned short snum)
  8 {
  9     bool reuse = sk->sk_reuse && sk->sk_state != TCP_LISTEN;
 10     struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo;
 11     int ret = 1, port = snum;
 12     struct inet_bind_hashbucket *head;
 13     struct net *net = sock_net(sk);
 14     struct inet_bind_bucket *tb = NULL;
 15     kuid_t uid = sock_i_uid(sk);
 16 
 17     /* 未设定端口，自动绑定 */
 18     if (!port) {
 19         /* 返回端口所在的桶节点 */
 20         head = inet_csk_find_open_port(sk, &tb, &port);
 21         /* 未找到桶节点 */
 22         if (!head)
 23             return ret;
 24         /* 没有相同节点，创建节点 */
 25         if (!tb)
 26             goto tb_not_found;
 27         
 28         /* 有相同节点，成功 */
 29         goto success;
 30     }
 31 
 32     /* 设置了端口，找到端口hash桶节点 */
 33     head = &hinfo->bhash[inet_bhashfn(net, port,
 34                       hinfo->bhash_size)];
 35     spin_lock_bh(&head->lock);
 36 
 37     /* 遍历该桶节点下面的所有端口 */
 38     inet_bind_bucket_for_each(tb, &head->chain)
 39         /* 找到相同端口 */
 40         if (net_eq(ib_net(tb), net) && tb->port == port)
 41             goto tb_found;
 42 tb_not_found:
 43     /* 创建绑定节点 */
 44     tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep,
 45                      net, head, port);
 46     if (!tb)
 47         goto fail_unlock;
 48 tb_found:
 49     /* 节点上有控制块 */
 50     if (!hlist_empty(&tb->owners)) {
 51         /* 强制绑定，成功 */
 52         if (sk->sk_reuse == SK_FORCE_REUSE)
 53             goto success;
 54 
 55         /* 快速的比对 */
 56         /* 已绑定的开启重用&&新请求绑定的开启了地址重用|| 端口重用检查通过，成功 */
 57         /* 先检查地址重用，未通过则检查端口重用 */
 58         if ((tb->fastreuse > 0 && reuse) ||
 59             sk_reuseport_match(tb, sk))
 60             goto success;
 61 
 62         /* 地址重用和端口重用fast检查都失败 */
 63 
 64         /* 走更精确的比对 */
 65         /* 注意，在指定端口的情况下，不需要进行严格检查，并且可以重用端口 */
 66         if (inet_csk_bind_conflict(sk, tb, true, true))
 67             goto fail_unlock;
 68     }
 69 success:
 70     /* 该节点有控制块共用 */
 71     if (!hlist_empty(&tb->owners)) {
 72         /* 设置地址重用标志 */
 73         tb->fastreuse = reuse;
 74 
 75         /* 如果开启端口重用 */
 76         if (sk->sk_reuseport) {
 77             tb->fastreuseport = FASTREUSEPORT_ANY;
 78             tb->fastuid = uid;
 79             tb->fast_rcv_saddr = sk->sk_rcv_saddr;
 80             tb->fast_ipv6_only = ipv6_only_sock(sk);
 81 #if IS_ENABLED(CONFIG_IPV6)
 82             tb->fast_v6_rcv_saddr = sk->sk_v6_rcv_saddr;
 83 #endif
 84         } 
 85         /* 未开启端口重用 */
 86         else {
 87             tb->fastreuseport = 0;
 88         }
 89     } 
 90     /* 该端口节点还没有其他控制块 */
 91     else {
 92         /* 未开启地址重用，置0 */
 93         if (!reuse)
 94             tb->fastreuse = 0;
 95 
 96         /* 开启了端口重用 */
 97         if (sk->sk_reuseport) {
 98             /* We didn't match or we don't have fastreuseport set on
 99              * the tb, but we have sk_reuseport set on this socket
100              * and we know that there are no bind conflicts with
101              * this socket in this tb, so reset our tb's reuseport
102              * settings so that any subsequent sockets that match
103              * our current socket will be put on the fast path.
104              *
105              * If we reset we need to set FASTREUSEPORT_STRICT so we
106              * do extra checking for all subsequent sk_reuseport
107              * socks.
108              */
109             if (!sk_reuseport_match(tb, sk)) {
110                 tb->fastreuseport = FASTREUSEPORT_STRICT;
111                 tb->fastuid = uid;
112                 tb->fast_rcv_saddr = sk->sk_rcv_saddr;
113                 tb->fast_ipv6_only = ipv6_only_sock(sk);
114 #if IS_ENABLED(CONFIG_IPV6)
115                 tb->fast_v6_rcv_saddr = sk->sk_v6_rcv_saddr;
116 #endif
117             }
118         }
119         /* 未开启端口重用 */
120         else {
121             tb->fastreuseport = 0;
122         }
123     }
124 
125     /* 添加到绑定hash */
126     if (!inet_csk(sk)->icsk_bind_hash)
127         inet_bind_hash(sk, tb, port);
128     WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);
129     ret = 0;
130 
131 fail_unlock:
132     spin_unlock_bh(&head->lock);
133     return ret;
134 }

对于未设置端口号的绑定，系统会在端口号范围内查找一个没有冲突的端口号；

  1 /*
  2  * Find an open port number for the socket.  Returns with the
  3  * inet_bind_hashbucket lock held.
  4  */
  5 static struct inet_bind_hashbucket *
  6 inet_csk_find_open_port(struct sock *sk, struct inet_bind_bucket **tb_ret, int *port_ret)
  7 {
  8     struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo;
  9     int port = 0;
 10     struct inet_bind_hashbucket *head;
 11     struct net *net = sock_net(sk);
 12     int i, low, high, attempt_half;
 13     struct inet_bind_bucket *tb;
 14     u32 remaining, offset;
 15 
 16     /* 地址重用则attempt_half设置为1 */
 17     attempt_half = (sk->sk_reuse == SK_CAN_REUSE) ? 1 : 0;
 18 other_half_scan:
 19     /* 获取端口范围区间 */
 20     inet_get_local_port_range(net, &low, &high);
 21     high++; /* [32768, 60999] -> [32768, 61000[ */
 22 
 23     /* 端口范围很小，attempt_half设置为0 */
 24     if (high - low < 4)
 25         attempt_half = 0;
 26     /* attempt_half不为0 */
 27     if (attempt_half) {
 28 
 29         /* 找到一半的位置 */
 30         int half = low + (((high - low) >> 2) << 1);
 31 
 32         /* 第一次尝试低一半 */
 33         if (attempt_half == 1)
 34             high = half;
 35         /* 否则尝试高一半 */
 36         else
 37             low = half;
 38     }
 39 
 40     /* 地址数 */
 41     remaining = high - low;
 42 
 43     /* 地址数消除低位 */
 44     if (likely(remaining > 1))
 45         remaining &= ~1U;
 46 
 47     /* 随机一个偏移 */
 48     offset = prandom_u32() % remaining;
 49     /* __inet_hash_connect() favors ports having @low parity
 50      * We do the opposite to not pollute connect() users.
 51      */
 52     /* 偏移低位置1 ，方便下面分半遍历端口*/
 53     offset |= 1U;
 54 
 55 other_parity_scan:
 56 
 57     /* 取一个端口 */
 58     port = low + offset;
 59 
 60     /* 遍历查找合适端口，先遍历一半端口 */
 61     for (i = 0; i < remaining; i += 2, port += 2) {
 62         if (unlikely(port >= high))
 63             port -= remaining;
 64 
 65         /* 如果端口配置为保留端口，继续下一个端口 */
 66         if (inet_is_local_reserved_port(net, port))
 67             continue;
 68 
 69         /* 找到该端口对应的绑定端口列表 */
 70         head = &hinfo->bhash[inet_bhashfn(net, port,
 71                           hinfo->bhash_size)];
 72         spin_lock_bh(&head->lock);
 73         /* 遍历该链表 */
 74         inet_bind_bucket_for_each(tb, &head->chain)
 75             /* 同一个命名空间&& 端口相同 */
 76             if (net_eq(ib_net(tb), net) && tb->port == port) {
 77                 /* 绑定无冲突，成功 */
 78                 /* 注意，随机端口，需要进行严谨的检查，并且不能使用端口重用 */
 79                 if (!inet_csk_bind_conflict(sk, tb, false, false))
 80                     goto success;
 81 
 82                 /* 有冲突，下一个端口 */
 83                 goto next_port;
 84             }
 85         /* 没有命名空间和端口相同，成功 */
 86         tb = NULL;
 87         goto success;
 88 next_port:
 89         spin_unlock_bh(&head->lock);
 90         cond_resched();
 91     }
 92 
 93     /* 遍历另外一半端口 */
 94     offset--;
 95     if (!(offset & 1))
 96         goto other_parity_scan;
 97 
 98     /* 端口均不能用，则尝试高位端口的一半 */
 99     if (attempt_half == 1) {
100         /* OK we now try the upper half of the range */
101         attempt_half = 2;
102         goto other_half_scan;
103     }
104     return NULL;
105 
106     /* 成功返回端口和节点(有端口相同时不为NULL) */
107 success:
108     *port_ret = port;
109     *tb_ret = tb;
110     return head;
111 }

inet_csk_bind_conflict用来判断端口是否冲突；

 1 static int inet_csk_bind_conflict(const struct sock *sk,
 2                   const struct inet_bind_bucket *tb,
 3                   bool relax, bool reuseport_ok)
 4 {
 5     struct sock *sk2;
 6     /* 地址重用 */
 7     bool reuse = sk->sk_reuse;
 8     /* 端口重用 */
 9     bool reuseport = !!sk->sk_reuseport && reuseport_ok;
10     /* 用户id */
11     kuid_t uid = sock_i_uid((struct sock *)sk);
12 
13     /*
14      * Unlike other sk lookup places we do not check
15      * for sk_net here, since _all_ the socks listed
16      * in tb->owners list belong to the same net - the
17      * one this bucket belongs to.
18      */
19     /* 遍历所有绑定控制块 */
20     sk_for_each_bound(sk2, &tb->owners) {
21         if (sk != sk2 && /* 控制块不同 */
22             /* 输出报文的网络接口号为0或者相等 */
23             (!sk->sk_bound_dev_if || 
24              !sk2->sk_bound_dev_if ||
25              sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
26 
27             /* 或逻辑好多，看着晕啊，看看什么情况下不需要判断吧 */
28 
29                /*
30                           未启用地址重用 && 未启用端口重用：检查冲突；
31                           启用了地址重用 && 未启用端口重用：状态是LISTEN才检查冲突；
32                           未启用地址重用 && 启用了端口重用：状态不是TIME_WAIT并且不是同一有效用户ID时，检查冲突；
33                                                          也就是说，假若是TIME_WAIT，则不需要检查；
34                                                          假如不是TIME_WAIT，但是有效用户ID相同，也不需要检查；
35 
36                           启用了地址重用 && 启用了端口重用：状态是LISTEN时，可能需要检查，需要继续判断端口重用，
37                                                           这时候只当有效用户ID不相同的时候，才需要检查；
38                                                           就是说，可以相同用户ID的进程可以同时LISTEN多个相同的地址+端口；
39                         */
40             
41             if ((!reuse || !sk2->sk_reuse ||
42                 sk2->sk_state == TCP_LISTEN) &&
43                 (!reuseport || !sk2->sk_reuseport ||
44                  rcu_access_pointer(sk->sk_reuseport_cb) ||
45                  (sk2->sk_state != TCP_TIME_WAIT &&
46                  !uid_eq(uid, sock_i_uid(sk2))))) {
47 
48                 /* 地址相同，冲突 */
49                 if (inet_rcv_saddr_equal(sk, sk2, true))
50                     break;
51             }
52 
53             /* 上面不需要判断的走到这里的情况 */
54             /* 情况1.新旧绑定都设置了地址重用，状态不是LISTEN ，不满足本条，继续下面2*/
55             /* 情况2.新旧绑定都设置了端口重用，状态是TIME_WAIT或者用户ID相等 */
56 
57 
58             /* 上面1情况如果不放宽检查，则检查 */
59             if (!relax && reuse && sk2->sk_reuse &&
60                 sk2->sk_state != TCP_LISTEN) {
61 
62                 /* 地址相同，冲突 */
63                 if (inet_rcv_saddr_equal(sk, sk2, true))
64                     break;
65             }
66         }
67     }
68     return sk2 != NULL;
69 }