~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv6/inet6_hashtables.c

Version: ~ [ linux-6.1-rc7 ] ~ [ linux-6.0.10 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.80 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.156 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.225 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.267 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.300 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.334 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
  3  *              operating system.  INET is implemented using the BSD Socket
  4  *              interface as the means of communication with the user level.
  5  *
  6  *              Generic INET6 transport hashtables
  7  *
  8  * Authors:     Lotsa people, from code originally in tcp, generalised here
  9  *              by Arnaldo Carvalho de Melo <acme@mandriva.com>
 10  *
 11  *      This program is free software; you can redistribute it and/or
 12  *      modify it under the terms of the GNU General Public License
 13  *      as published by the Free Software Foundation; either version
 14  *      2 of the License, or (at your option) any later version.
 15  */
 16 
 17 #include <linux/module.h>
 18 #include <linux/random.h>
 19 
 20 #include <net/inet_connection_sock.h>
 21 #include <net/inet_hashtables.h>
 22 #include <net/inet6_hashtables.h>
 23 #include <net/secure_seq.h>
 24 #include <net/ip.h>
 25 
 26 u32 inet6_ehashfn(const struct net *net,
 27                   const struct in6_addr *laddr, const u16 lport,
 28                   const struct in6_addr *faddr, const __be16 fport)
 29 {
 30         static u32 inet6_ehash_secret __read_mostly;
 31         static u32 ipv6_hash_secret __read_mostly;
 32 
 33         u32 lhash, fhash;
 34 
 35         net_get_random_once(&inet6_ehash_secret, sizeof(inet6_ehash_secret));
 36         net_get_random_once(&ipv6_hash_secret, sizeof(ipv6_hash_secret));
 37 
 38         lhash = (__force u32)laddr->s6_addr32[3];
 39         fhash = __ipv6_addr_jhash(faddr, ipv6_hash_secret);
 40 
 41         return __inet6_ehashfn(lhash, lport, fhash, fport,
 42                                inet6_ehash_secret + net_hash_mix(net));
 43 }
 44 
 45 /*
 46  * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
 47  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
 48  *
 49  * The sockhash lock must be held as a reader here.
 50  */
 51 struct sock *__inet6_lookup_established(struct net *net,
 52                                         struct inet_hashinfo *hashinfo,
 53                                            const struct in6_addr *saddr,
 54                                            const __be16 sport,
 55                                            const struct in6_addr *daddr,
 56                                            const u16 hnum,
 57                                            const int dif)
 58 {
 59         struct sock *sk;
 60         const struct hlist_nulls_node *node;
 61         const __portpair ports = INET_COMBINED_PORTS(sport, hnum);
 62         /* Optimize here for direct hit, only listening connections can
 63          * have wildcards anyways.
 64          */
 65         unsigned int hash = inet6_ehashfn(net, daddr, hnum, saddr, sport);
 66         unsigned int slot = hash & hashinfo->ehash_mask;
 67         struct inet_ehash_bucket *head = &hashinfo->ehash[slot];
 68 
 69 
 70         rcu_read_lock();
 71 begin:
 72         sk_nulls_for_each_rcu(sk, node, &head->chain) {
 73                 if (sk->sk_hash != hash)
 74                         continue;
 75                 if (!INET6_MATCH(sk, net, saddr, daddr, ports, dif))
 76                         continue;
 77                 if (unlikely(!atomic_inc_not_zero(&sk->sk_refcnt)))
 78                         goto out;
 79 
 80                 if (unlikely(!INET6_MATCH(sk, net, saddr, daddr, ports, dif))) {
 81                         sock_gen_put(sk);
 82                         goto begin;
 83                 }
 84                 goto found;
 85         }
 86         if (get_nulls_value(node) != slot)
 87                 goto begin;
 88 out:
 89         sk = NULL;
 90 found:
 91         rcu_read_unlock();
 92         return sk;
 93 }
 94 EXPORT_SYMBOL(__inet6_lookup_established);
 95 
 96 static inline int compute_score(struct sock *sk, struct net *net,
 97                                 const unsigned short hnum,
 98                                 const struct in6_addr *daddr,
 99                                 const int dif)
100 {
101         int score = -1;
102 
103         if (net_eq(sock_net(sk), net) && inet_sk(sk)->inet_num == hnum &&
104             sk->sk_family == PF_INET6) {
105 
106                 score = 1;
107                 if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
108                         if (!ipv6_addr_equal(&sk->sk_v6_rcv_saddr, daddr))
109                                 return -1;
110                         score++;
111                 }
112                 if (sk->sk_bound_dev_if) {
113                         if (sk->sk_bound_dev_if != dif)
114                                 return -1;
115                         score++;
116                 }
117                 if (sk->sk_incoming_cpu == raw_smp_processor_id())
118                         score++;
119         }
120         return score;
121 }
122 
123 struct sock *inet6_lookup_listener(struct net *net,
124                 struct inet_hashinfo *hashinfo, const struct in6_addr *saddr,
125                 const __be16 sport, const struct in6_addr *daddr,
126                 const unsigned short hnum, const int dif)
127 {
128         struct sock *sk;
129         const struct hlist_nulls_node *node;
130         struct sock *result;
131         int score, hiscore, matches = 0, reuseport = 0;
132         u32 phash = 0;
133         unsigned int hash = inet_lhashfn(net, hnum);
134         struct inet_listen_hashbucket *ilb = &hashinfo->listening_hash[hash];
135 
136         rcu_read_lock();
137 begin:
138         result = NULL;
139         hiscore = 0;
140         sk_nulls_for_each(sk, node, &ilb->head) {
141                 score = compute_score(sk, net, hnum, daddr, dif);
142                 if (score > hiscore) {
143                         hiscore = score;
144                         result = sk;
145                         reuseport = sk->sk_reuseport;
146                         if (reuseport) {
147                                 phash = inet6_ehashfn(net, daddr, hnum,
148                                                       saddr, sport);
149                                 matches = 1;
150                         }
151                 } else if (score == hiscore && reuseport) {
152                         matches++;
153                         if (reciprocal_scale(phash, matches) == 0)
154                                 result = sk;
155                         phash = next_pseudo_random32(phash);
156                 }
157         }
158         /*
159          * if the nulls value we got at the end of this lookup is
160          * not the expected one, we must restart lookup.
161          * We probably met an item that was moved to another chain.
162          */
163         if (get_nulls_value(node) != hash + LISTENING_NULLS_BASE)
164                 goto begin;
165         if (result) {
166                 if (unlikely(!atomic_inc_not_zero(&result->sk_refcnt)))
167                         result = NULL;
168                 else if (unlikely(compute_score(result, net, hnum, daddr,
169                                   dif) < hiscore)) {
170                         sock_put(result);
171                         goto begin;
172                 }
173         }
174         rcu_read_unlock();
175         return result;
176 }
177 EXPORT_SYMBOL_GPL(inet6_lookup_listener);
178 
179 struct sock *inet6_lookup(struct net *net, struct inet_hashinfo *hashinfo,
180                           const struct in6_addr *saddr, const __be16 sport,
181                           const struct in6_addr *daddr, const __be16 dport,
182                           const int dif)
183 {
184         struct sock *sk;
185 
186         local_bh_disable();
187         sk = __inet6_lookup(net, hashinfo, saddr, sport, daddr, ntohs(dport), dif);
188         local_bh_enable();
189 
190         return sk;
191 }
192 EXPORT_SYMBOL_GPL(inet6_lookup);
193 
194 static int __inet6_check_established(struct inet_timewait_death_row *death_row,
195                                      struct sock *sk, const __u16 lport,
196                                      struct inet_timewait_sock **twp)
197 {
198         struct inet_hashinfo *hinfo = death_row->hashinfo;
199         struct inet_sock *inet = inet_sk(sk);
200         const struct in6_addr *daddr = &sk->sk_v6_rcv_saddr;
201         const struct in6_addr *saddr = &sk->sk_v6_daddr;
202         const int dif = sk->sk_bound_dev_if;
203         const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport);
204         struct net *net = sock_net(sk);
205         const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr,
206                                                 inet->inet_dport);
207         struct inet_ehash_bucket *head = inet_ehash_bucket(hinfo, hash);
208         spinlock_t *lock = inet_ehash_lockp(hinfo, hash);
209         struct sock *sk2;
210         const struct hlist_nulls_node *node;
211         struct inet_timewait_sock *tw = NULL;
212 
213         spin_lock(lock);
214 
215         sk_nulls_for_each(sk2, node, &head->chain) {
216                 if (sk2->sk_hash != hash)
217                         continue;
218 
219                 if (likely(INET6_MATCH(sk2, net, saddr, daddr, ports, dif))) {
220                         if (sk2->sk_state == TCP_TIME_WAIT) {
221                                 tw = inet_twsk(sk2);
222                                 if (twsk_unique(sk, sk2, twp))
223                                         break;
224                         }
225                         goto not_unique;
226                 }
227         }
228 
229         /* Must record num and sport now. Otherwise we will see
230          * in hash table socket with a funny identity.
231          */
232         inet->inet_num = lport;
233         inet->inet_sport = htons(lport);
234         sk->sk_hash = hash;
235         WARN_ON(!sk_unhashed(sk));
236         __sk_nulls_add_node_rcu(sk, &head->chain);
237         if (tw) {
238                 sk_nulls_del_node_init_rcu((struct sock *)tw);
239                 NET_INC_STATS_BH(net, LINUX_MIB_TIMEWAITRECYCLED);
240         }
241         spin_unlock(lock);
242         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
243 
244         if (twp) {
245                 *twp = tw;
246         } else if (tw) {
247                 /* Silly. Should hash-dance instead... */
248                 inet_twsk_deschedule_put(tw);
249         }
250         return 0;
251 
252 not_unique:
253         spin_unlock(lock);
254         return -EADDRNOTAVAIL;
255 }
256 
257 static u32 inet6_sk_port_offset(const struct sock *sk)
258 {
259         const struct inet_sock *inet = inet_sk(sk);
260 
261         return secure_ipv6_port_ephemeral(sk->sk_v6_rcv_saddr.s6_addr32,
262                                           sk->sk_v6_daddr.s6_addr32,
263                                           inet->inet_dport);
264 }
265 
266 int inet6_hash_connect(struct inet_timewait_death_row *death_row,
267                        struct sock *sk)
268 {
269         u32 port_offset = 0;
270 
271         if (!inet_sk(sk)->inet_num)
272                 port_offset = inet6_sk_port_offset(sk);
273         return __inet_hash_connect(death_row, sk, port_offset,
274                                    __inet6_check_established);
275 }
276 EXPORT_SYMBOL_GPL(inet6_hash_connect);
277 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp