LCOV - code coverage report
Current view: top level - net/ipv6 - inet6_hashtables.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 87 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 9 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14