tcp: Don't pass hashinfo to socket lookup helpers.

tjh.dev / kernel

fork atom

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

fork atom

tcp: Don't pass hashinfo to socket lookup helpers.

These socket lookup functions required struct inet_hashinfo because
they are shared by TCP and DCCP.

* __inet_lookup_established()
* __inet_lookup_listener()
* __inet6_lookup_established()
* inet6_lookup_listener()

DCCP has gone, and we don't need to pass hashinfo down to them.

Let's fetch net->ipv4.tcp_death_row.hashinfo directly in the above
4 functions.

Signed-off-by: Kuniyuki Iwashima <kuniyu@google.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Link: https://patch.msgid.link/20250822190803.540788-5-kuniyu@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

authored by

Kuniyuki Iwashima and committed by

Jakub Kicinski 7 months ago cb16f4b6 8150f3a4

+94 -123

18 changed files

expand all collapse all

drivers

net

ethernet

mellanox

mlx5

core

en_accel

ktls_rx.c

netronome

nfp

crypto

tls.c

include

net

inet6_hashtables.h

inet_hashtables.h

net

core

filter.c

ipv4

esp4.c

inet_diag.c

inet_hashtables.c

netfilter

nf_socket_ipv4.c

nf_tproxy_ipv4.c

tcp_ipv4.c

tcp_offload.c

ipv6

esp6.c

inet6_hashtables.c

netfilter

nf_socket_ipv6.c

nf_tproxy_ipv6.c

tcp_ipv6.c

tcpv6_offload.c

+4 -5

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_rx.c

reviewed

··· 498 498 depth += sizeof(struct iphdr); 499 499 th = (void *)iph + sizeof(struct iphdr); 500 500 501 501 - sk = inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 502 502 - iph->saddr, th->source, iph->daddr, 503 503 - th->dest, netdev->ifindex); 501 501 + sk = inet_lookup_established(net, iph->saddr, th->source, 502 502 + iph->daddr, th->dest, 503 503 + netdev->ifindex); 504 504 #if IS_ENABLED(CONFIG_IPV6) 505 505 } else { 506 506 struct ipv6hdr *ipv6h = (struct ipv6hdr *)iph; ··· 508 508 depth += sizeof(struct ipv6hdr); 509 509 th = (void *)ipv6h + sizeof(struct ipv6hdr); 510 510 511 511 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 512 512 - &ipv6h->saddr, th->source, 511 511 + sk = __inet6_lookup_established(net, &ipv6h->saddr, th->source, 513 512 &ipv6h->daddr, ntohs(th->dest), 514 513 netdev->ifindex, 0); 515 514 #endif

+4 -5

drivers/net/ethernet/netronome/nfp/crypto/tls.c

reviewed

··· 495 495 496 496 switch (ipv6h->version) { 497 497 case 4: 498 498 - sk = inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 499 499 - iph->saddr, th->source, iph->daddr, 500 500 - th->dest, netdev->ifindex); 498 498 + sk = inet_lookup_established(net, iph->saddr, th->source, 499 499 + iph->daddr, th->dest, 500 500 + netdev->ifindex); 501 501 break; 502 502 #if IS_ENABLED(CONFIG_IPV6) 503 503 case 6: 504 504 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 505 505 - &ipv6h->saddr, th->source, 504 504 + sk = __inet6_lookup_established(net, &ipv6h->saddr, th->source, 506 505 &ipv6h->daddr, ntohs(th->dest), 507 506 netdev->ifindex, 0); 508 507 break;

+6 -12

include/net/inet6_hashtables.h

reviewed

··· 41 41 * The sockhash lock must be held as a reader here. 42 42 */ 43 43 struct sock *__inet6_lookup_established(const struct net *net, 44 44 - struct inet_hashinfo *hashinfo, 45 44 const struct in6_addr *saddr, 46 45 const __be16 sport, 47 46 const struct in6_addr *daddr, ··· 64 65 inet6_ehashfn_t *ehashfn); 65 66 66 67 struct sock *inet6_lookup_listener(const struct net *net, 67 67 - struct inet_hashinfo *hashinfo, 68 68 struct sk_buff *skb, int doff, 69 69 const struct in6_addr *saddr, 70 70 const __be16 sport, ··· 81 83 inet6_ehashfn_t *ehashfn); 82 84 83 85 static inline struct sock *__inet6_lookup(const struct net *net, 84 84 - struct inet_hashinfo *hashinfo, 85 86 struct sk_buff *skb, int doff, 86 87 const struct in6_addr *saddr, 87 88 const __be16 sport, ··· 89 92 const int dif, const int sdif, 90 93 bool *refcounted) 91 94 { 92 92 - struct sock *sk = __inet6_lookup_established(net, hashinfo, saddr, 93 93 - sport, daddr, hnum, 95 95 + struct sock *sk = __inet6_lookup_established(net, saddr, sport, 96 96 + daddr, hnum, 94 97 dif, sdif); 95 98 *refcounted = true; 96 99 if (sk) 97 100 return sk; 98 101 *refcounted = false; 99 99 - return inet6_lookup_listener(net, hashinfo, skb, doff, saddr, sport, 102 102 + return inet6_lookup_listener(net, skb, doff, saddr, sport, 100 103 daddr, hnum, dif, sdif); 101 104 } 102 105 ··· 140 143 return reuse_sk; 141 144 } 142 145 143 143 - static inline struct sock *__inet6_lookup_skb(struct inet_hashinfo *hashinfo, 144 144 - struct sk_buff *skb, int doff, 146 146 + static inline struct sock *__inet6_lookup_skb(struct sk_buff *skb, int doff, 145 147 const __be16 sport, 146 148 const __be16 dport, 147 149 int iif, int sdif, ··· 157 161 if (sk) 158 162 return sk; 159 163 160 160 - return __inet6_lookup(net, hashinfo, skb, 161 161 - doff, &ip6h->saddr, sport, 164 164 + return __inet6_lookup(net, skb, doff, &ip6h->saddr, sport, 162 165 &ip6h->daddr, ntohs(dport), 163 166 iif, sdif, refcounted); 164 167 } 165 168 166 166 - struct sock *inet6_lookup(const struct net *net, struct inet_hashinfo *hashinfo, 167 167 - struct sk_buff *skb, int doff, 169 169 + struct sock *inet6_lookup(const struct net *net, struct sk_buff *skb, int doff, 168 170 const struct in6_addr *saddr, const __be16 sport, 169 171 const struct in6_addr *daddr, const __be16 dport, 170 172 const int dif);

+15 -22

include/net/inet_hashtables.h

reviewed

··· 294 294 void inet_unhash(struct sock *sk); 295 295 296 296 struct sock *__inet_lookup_listener(const struct net *net, 297 297 - struct inet_hashinfo *hashinfo, 298 297 struct sk_buff *skb, int doff, 299 298 const __be32 saddr, const __be16 sport, 300 299 const __be32 daddr, ··· 301 302 const int dif, const int sdif); 302 303 303 304 static inline struct sock *inet_lookup_listener(struct net *net, 304 304 - struct inet_hashinfo *hashinfo, 305 305 - struct sk_buff *skb, int doff, 306 306 - __be32 saddr, __be16 sport, 307 307 - __be32 daddr, __be16 dport, int dif, int sdif) 305 305 + struct sk_buff *skb, int doff, 306 306 + __be32 saddr, __be16 sport, 307 307 + __be32 daddr, __be16 dport, 308 308 + int dif, int sdif) 308 309 { 309 309 - return __inet_lookup_listener(net, hashinfo, skb, doff, saddr, sport, 310 310 + return __inet_lookup_listener(net, skb, doff, saddr, sport, 310 311 daddr, ntohs(dport), dif, sdif); 311 312 } 312 313 ··· 357 358 * not check it for lookups anymore, thanks Alexey. -DaveM 358 359 */ 359 360 struct sock *__inet_lookup_established(const struct net *net, 360 360 - struct inet_hashinfo *hashinfo, 361 361 const __be32 saddr, const __be16 sport, 362 362 const __be32 daddr, const u16 hnum, 363 363 const int dif, const int sdif); ··· 382 384 __be32 daddr, u16 hnum, const int dif, 383 385 inet_ehashfn_t *ehashfn); 384 386 385 385 - static inline struct sock * 386 386 - inet_lookup_established(struct net *net, struct inet_hashinfo *hashinfo, 387 387 - const __be32 saddr, const __be16 sport, 388 388 - const __be32 daddr, const __be16 dport, 389 389 - const int dif) 387 387 + static inline struct sock *inet_lookup_established(struct net *net, 388 388 + const __be32 saddr, const __be16 sport, 389 389 + const __be32 daddr, const __be16 dport, 390 390 + const int dif) 390 391 { 391 391 - return __inet_lookup_established(net, hashinfo, saddr, sport, daddr, 392 392 + return __inet_lookup_established(net, saddr, sport, daddr, 392 393 ntohs(dport), dif, 0); 393 394 } 394 395 395 396 static inline struct sock *__inet_lookup(struct net *net, 396 396 - struct inet_hashinfo *hashinfo, 397 397 struct sk_buff *skb, int doff, 398 398 const __be32 saddr, const __be16 sport, 399 399 const __be32 daddr, const __be16 dport, ··· 401 405 u16 hnum = ntohs(dport); 402 406 struct sock *sk; 403 407 404 404 - sk = __inet_lookup_established(net, hashinfo, saddr, sport, 408 408 + sk = __inet_lookup_established(net, saddr, sport, 405 409 daddr, hnum, dif, sdif); 406 410 *refcounted = true; 407 411 if (sk) 408 412 return sk; 409 413 *refcounted = false; 410 410 - return __inet_lookup_listener(net, hashinfo, skb, doff, saddr, 414 414 + return __inet_lookup_listener(net, skb, doff, saddr, 411 415 sport, daddr, hnum, dif, sdif); 412 416 } 413 417 414 418 static inline struct sock *inet_lookup(struct net *net, 415 415 - struct inet_hashinfo *hashinfo, 416 419 struct sk_buff *skb, int doff, 417 420 const __be32 saddr, const __be16 sport, 418 421 const __be32 daddr, const __be16 dport, ··· 420 425 struct sock *sk; 421 426 bool refcounted; 422 427 423 423 - sk = __inet_lookup(net, hashinfo, skb, doff, saddr, sport, daddr, 428 428 + sk = __inet_lookup(net, skb, doff, saddr, sport, daddr, 424 429 dport, dif, 0, &refcounted); 425 430 426 431 if (sk && !refcounted && !refcount_inc_not_zero(&sk->sk_refcnt)) ··· 468 473 return reuse_sk; 469 474 } 470 475 471 471 - static inline struct sock *__inet_lookup_skb(struct inet_hashinfo *hashinfo, 472 472 - struct sk_buff *skb, 476 476 + static inline struct sock *__inet_lookup_skb(struct sk_buff *skb, 473 477 int doff, 474 478 const __be16 sport, 475 479 const __be16 dport, ··· 486 492 if (sk) 487 493 return sk; 488 494 489 489 - return __inet_lookup(net, hashinfo, skb, 490 490 - doff, iph->saddr, sport, 495 495 + return __inet_lookup(net, skb, doff, iph->saddr, sport, 491 496 iph->daddr, dport, inet_iif(skb), sdif, 492 497 refcounted); 493 498 }

+2 -3

net/core/filter.c

reviewed

··· 6767 6767 static struct sock *sk_lookup(struct net *net, struct bpf_sock_tuple *tuple, 6768 6768 int dif, int sdif, u8 family, u8 proto) 6769 6769 { 6770 6770 - struct inet_hashinfo *hinfo = net->ipv4.tcp_death_row.hashinfo; 6771 6770 bool refcounted = false; 6772 6771 struct sock *sk = NULL; 6773 6772 ··· 6775 6776 __be32 dst4 = tuple->ipv4.daddr; 6776 6777 6777 6778 if (proto == IPPROTO_TCP) 6778 6778 - sk = __inet_lookup(net, hinfo, NULL, 0, 6779 6779 + sk = __inet_lookup(net, NULL, 0, 6779 6780 src4, tuple->ipv4.sport, 6780 6781 dst4, tuple->ipv4.dport, 6781 6782 dif, sdif, &refcounted); ··· 6789 6790 struct in6_addr *dst6 = (struct in6_addr *)&tuple->ipv6.daddr; 6790 6791 6791 6792 if (proto == IPPROTO_TCP) 6792 6792 - sk = __inet6_lookup(net, hinfo, NULL, 0, 6793 6793 + sk = __inet6_lookup(net, NULL, 0, 6793 6794 src6, tuple->ipv6.sport, 6794 6795 dst6, ntohs(tuple->ipv6.dport), 6795 6796 dif, sdif, &refcounted);

+2 -2

net/ipv4/esp4.c

reviewed

··· 132 132 dport = encap->encap_dport; 133 133 spin_unlock_bh(&x->lock); 134 134 135 135 - sk = inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, x->id.daddr.a4, 136 136 - dport, x->props.saddr.a4, sport, 0); 135 135 + sk = inet_lookup_established(net, x->id.daddr.a4, dport, 136 136 + x->props.saddr.a4, sport, 0); 137 137 if (!sk) 138 138 return ERR_PTR(-ENOENT); 139 139

+3 -3

net/ipv4/inet_diag.c

reviewed

··· 526 526 527 527 rcu_read_lock(); 528 528 if (req->sdiag_family == AF_INET) 529 529 - sk = inet_lookup(net, hashinfo, NULL, 0, req->id.idiag_dst[0], 529 529 + sk = inet_lookup(net, NULL, 0, req->id.idiag_dst[0], 530 530 req->id.idiag_dport, req->id.idiag_src[0], 531 531 req->id.idiag_sport, req->id.idiag_if); 532 532 #if IS_ENABLED(CONFIG_IPV6) 533 533 else if (req->sdiag_family == AF_INET6) { 534 534 if (ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_dst) && 535 535 ipv6_addr_v4mapped((struct in6_addr *)req->id.idiag_src)) 536 536 - sk = inet_lookup(net, hashinfo, NULL, 0, req->id.idiag_dst[3], 536 536 + sk = inet_lookup(net, NULL, 0, req->id.idiag_dst[3], 537 537 req->id.idiag_dport, req->id.idiag_src[3], 538 538 req->id.idiag_sport, req->id.idiag_if); 539 539 else 540 540 - sk = inet6_lookup(net, hashinfo, NULL, 0, 540 540 + sk = inet6_lookup(net, NULL, 0, 541 541 (struct in6_addr *)req->id.idiag_dst, 542 542 req->id.idiag_dport, 543 543 (struct in6_addr *)req->id.idiag_src,

+15 -13

net/ipv4/inet_hashtables.c

reviewed

··· 425 425 } 426 426 427 427 struct sock *__inet_lookup_listener(const struct net *net, 428 428 - struct inet_hashinfo *hashinfo, 429 428 struct sk_buff *skb, int doff, 430 429 const __be32 saddr, __be16 sport, 431 430 const __be32 daddr, const unsigned short hnum, 432 431 const int dif, const int sdif) 433 432 { 434 433 struct inet_listen_hashbucket *ilb2; 434 434 + struct inet_hashinfo *hashinfo; 435 435 struct sock *result = NULL; 436 436 unsigned int hash2; 437 437 ··· 444 444 goto done; 445 445 } 446 446 447 447 + hashinfo = net->ipv4.tcp_death_row.hashinfo; 447 448 hash2 = ipv4_portaddr_hash(net, daddr, hnum); 448 449 ilb2 = inet_lhash2_bucket(hashinfo, hash2); 449 450 ··· 490 489 EXPORT_SYMBOL(sock_edemux); 491 490 492 491 struct sock *__inet_lookup_established(const struct net *net, 493 493 - struct inet_hashinfo *hashinfo, 494 494 - const __be32 saddr, const __be16 sport, 495 495 - const __be32 daddr, const u16 hnum, 496 496 - const int dif, const int sdif) 492 492 + const __be32 saddr, const __be16 sport, 493 493 + const __be32 daddr, const u16 hnum, 494 494 + const int dif, const int sdif) 497 495 { 498 498 - INET_ADDR_COOKIE(acookie, saddr, daddr); 499 496 const __portpair ports = INET_COMBINED_PORTS(sport, hnum); 500 500 - struct sock *sk; 497 497 + INET_ADDR_COOKIE(acookie, saddr, daddr); 501 498 const struct hlist_nulls_node *node; 502 502 - /* Optimize here for direct hit, only listening connections can 503 503 - * have wildcards anyways. 504 504 - */ 505 505 - unsigned int hash = inet_ehashfn(net, daddr, hnum, saddr, sport); 506 506 - unsigned int slot = hash & hashinfo->ehash_mask; 507 507 - struct inet_ehash_bucket *head = &hashinfo->ehash[slot]; 499 499 + struct inet_ehash_bucket *head; 500 500 + struct inet_hashinfo *hashinfo; 501 501 + unsigned int hash, slot; 502 502 + struct sock *sk; 503 503 + 504 504 + hashinfo = net->ipv4.tcp_death_row.hashinfo; 505 505 + hash = inet_ehashfn(net, daddr, hnum, saddr, sport); 506 506 + slot = hash & hashinfo->ehash_mask; 507 507 + head = &hashinfo->ehash[slot]; 508 508 509 509 begin: 510 510 sk_nulls_for_each_rcu(sk, node, &head->chain) {

+1 -2

net/ipv4/netfilter/nf_socket_ipv4.c

reviewed

··· 71 71 { 72 72 switch (protocol) { 73 73 case IPPROTO_TCP: 74 74 - return inet_lookup(net, net->ipv4.tcp_death_row.hashinfo, 75 75 - skb, doff, saddr, sport, daddr, dport, 74 74 + return inet_lookup(net, skb, doff, saddr, sport, daddr, dport, 76 75 in->ifindex); 77 76 case IPPROTO_UDP: 78 77 return udp4_lib_lookup(net, saddr, sport, daddr, dport,

+2 -3

net/ipv4/netfilter/nf_tproxy_ipv4.c

reviewed

··· 81 81 const struct net_device *in, 82 82 const enum nf_tproxy_lookup_t lookup_type) 83 83 { 84 84 - struct inet_hashinfo *hinfo = net->ipv4.tcp_death_row.hashinfo; 85 84 struct sock *sk; 86 85 87 86 switch (protocol) { ··· 94 95 95 96 switch (lookup_type) { 96 97 case NF_TPROXY_LOOKUP_LISTENER: 97 97 - sk = inet_lookup_listener(net, hinfo, skb, 98 98 + sk = inet_lookup_listener(net, skb, 98 99 ip_hdrlen(skb) + __tcp_hdrlen(hp), 99 100 saddr, sport, daddr, dport, 100 101 in->ifindex, 0); ··· 108 109 */ 109 110 break; 110 111 case NF_TPROXY_LOOKUP_ESTABLISHED: 111 111 - sk = inet_lookup_established(net, hinfo, saddr, sport, 112 112 + sk = inet_lookup_established(net, saddr, sport, 112 113 daddr, dport, in->ifindex); 113 114 break; 114 115 default:

+5 -11

net/ipv4/tcp_ipv4.c

reviewed

··· 506 506 struct sock *sk; 507 507 int err; 508 508 509 509 - sk = __inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 510 510 - iph->daddr, th->dest, iph->saddr, 509 509 + sk = __inet_lookup_established(net, iph->daddr, th->dest, iph->saddr, 511 510 ntohs(th->source), inet_iif(skb), 0); 512 511 if (!sk) { 513 512 __ICMP_INC_STATS(net, ICMP_MIB_INERRORS); ··· 822 823 * Incoming packet is checked with md5 hash with finding key, 823 824 * no RST generated if md5 hash doesn't match. 824 825 */ 825 825 - sk1 = __inet_lookup_listener(net, net->ipv4.tcp_death_row.hashinfo, 826 826 - NULL, 0, ip_hdr(skb)->saddr, 826 826 + sk1 = __inet_lookup_listener(net, NULL, 0, ip_hdr(skb)->saddr, 827 827 th->source, ip_hdr(skb)->daddr, 828 828 ntohs(th->source), dif, sdif); 829 829 /* don't send rst if it can't find key */ ··· 1990 1992 if (th->doff < sizeof(struct tcphdr) / 4) 1991 1993 return 0; 1992 1994 1993 1993 - sk = __inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 1994 1994 - iph->saddr, th->source, 1995 1995 + sk = __inet_lookup_established(net, iph->saddr, th->source, 1995 1996 iph->daddr, ntohs(th->dest), 1996 1997 skb->skb_iif, inet_sdif(skb)); 1997 1998 if (sk) { ··· 2233 2236 th = (const struct tcphdr *)skb->data; 2234 2237 iph = ip_hdr(skb); 2235 2238 lookup: 2236 2236 - sk = __inet_lookup_skb(net->ipv4.tcp_death_row.hashinfo, 2237 2237 - skb, __tcp_hdrlen(th), th->source, 2239 2239 + sk = __inet_lookup_skb(skb, __tcp_hdrlen(th), th->source, 2238 2240 th->dest, sdif, &refcounted); 2239 2241 if (!sk) 2240 2242 goto no_tcp_socket; ··· 2422 2426 &drop_reason); 2423 2427 switch (tw_status) { 2424 2428 case TCP_TW_SYN: { 2425 2425 - struct sock *sk2 = inet_lookup_listener(net, 2426 2426 - net->ipv4.tcp_death_row.hashinfo, 2427 2427 - skb, __tcp_hdrlen(th), 2429 2429 + struct sock *sk2 = inet_lookup_listener(net, skb, __tcp_hdrlen(th), 2428 2430 iph->saddr, th->source, 2429 2431 iph->daddr, th->dest, 2430 2432 inet_iif(skb),

+1 -2

net/ipv4/tcp_offload.c

reviewed

··· 434 434 inet_get_iif_sdif(skb, &iif, &sdif); 435 435 iph = skb_gro_network_header(skb); 436 436 net = dev_net_rcu(skb->dev); 437 437 - sk = __inet_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 438 438 - iph->saddr, th->source, 437 437 + sk = __inet_lookup_established(net, iph->saddr, th->source, 439 438 iph->daddr, ntohs(th->dest), 440 439 iif, sdif); 441 440 NAPI_GRO_CB(skb)->is_flist = !sk;

+2 -2

net/ipv6/esp6.c

reviewed

··· 149 149 dport = encap->encap_dport; 150 150 spin_unlock_bh(&x->lock); 151 151 152 152 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, &x->id.daddr.in6, 153 153 - dport, &x->props.saddr.in6, ntohs(sport), 0, 0); 152 152 + sk = __inet6_lookup_established(net, &x->id.daddr.in6, dport, 153 153 + &x->props.saddr.in6, ntohs(sport), 0, 0); 154 154 if (!sk) 155 155 return ERR_PTR(-ENOENT); 156 156

+23 -22

net/ipv6/inet6_hashtables.c

reviewed

··· 47 47 * The sockhash lock must be held as a reader here. 48 48 */ 49 49 struct sock *__inet6_lookup_established(const struct net *net, 50 50 - struct inet_hashinfo *hashinfo, 51 51 - const struct in6_addr *saddr, 52 52 - const __be16 sport, 53 53 - const struct in6_addr *daddr, 54 54 - const u16 hnum, 55 55 - const int dif, const int sdif) 50 50 + const struct in6_addr *saddr, 51 51 + const __be16 sport, 52 52 + const struct in6_addr *daddr, 53 53 + const u16 hnum, 54 54 + const int dif, const int sdif) 56 55 { 57 57 - struct sock *sk; 58 58 - const struct hlist_nulls_node *node; 59 56 const __portpair ports = INET_COMBINED_PORTS(sport, hnum); 60 60 - /* Optimize here for direct hit, only listening connections can 61 61 - * have wildcards anyways. 62 62 - */ 63 63 - unsigned int hash = inet6_ehashfn(net, daddr, hnum, saddr, sport); 64 64 - unsigned int slot = hash & hashinfo->ehash_mask; 65 65 - struct inet_ehash_bucket *head = &hashinfo->ehash[slot]; 57 57 + const struct hlist_nulls_node *node; 58 58 + struct inet_ehash_bucket *head; 59 59 + struct inet_hashinfo *hashinfo; 60 60 + unsigned int hash, slot; 61 61 + struct sock *sk; 66 62 67 67 - 63 63 + hashinfo = net->ipv4.tcp_death_row.hashinfo; 64 64 + hash = inet6_ehashfn(net, daddr, hnum, saddr, sport); 65 65 + slot = hash & hashinfo->ehash_mask; 66 66 + head = &hashinfo->ehash[slot]; 68 67 begin: 69 68 sk_nulls_for_each_rcu(sk, node, &head->chain) { 70 69 if (sk->sk_hash != hash) ··· 199 200 EXPORT_SYMBOL_GPL(inet6_lookup_run_sk_lookup); 200 201 201 202 struct sock *inet6_lookup_listener(const struct net *net, 202 202 - struct inet_hashinfo *hashinfo, 203 203 - struct sk_buff *skb, int doff, 204 204 - const struct in6_addr *saddr, 205 205 - const __be16 sport, const struct in6_addr *daddr, 206 206 - const unsigned short hnum, const int dif, const int sdif) 203 203 + struct sk_buff *skb, int doff, 204 204 + const struct in6_addr *saddr, 205 205 + const __be16 sport, 206 206 + const struct in6_addr *daddr, 207 207 + const unsigned short hnum, 208 208 + const int dif, const int sdif) 207 209 { 208 210 struct inet_listen_hashbucket *ilb2; 211 211 + struct inet_hashinfo *hashinfo; 209 212 struct sock *result = NULL; 210 213 unsigned int hash2; 211 214 ··· 220 219 goto done; 221 220 } 222 221 222 222 + hashinfo = net->ipv4.tcp_death_row.hashinfo; 223 223 hash2 = ipv6_portaddr_hash(net, daddr, hnum); 224 224 ilb2 = inet_lhash2_bucket(hashinfo, hash2); 225 225 ··· 245 243 EXPORT_SYMBOL_GPL(inet6_lookup_listener); 246 244 247 245 struct sock *inet6_lookup(const struct net *net, 248 248 - struct inet_hashinfo *hashinfo, 249 246 struct sk_buff *skb, int doff, 250 247 const struct in6_addr *saddr, const __be16 sport, 251 248 const struct in6_addr *daddr, const __be16 dport, ··· 253 252 struct sock *sk; 254 253 bool refcounted; 255 254 256 256 - sk = __inet6_lookup(net, hashinfo, skb, doff, saddr, sport, daddr, 255 255 + sk = __inet6_lookup(net, skb, doff, saddr, sport, daddr, 257 256 ntohs(dport), dif, 0, &refcounted); 258 257 if (sk && !refcounted && !refcount_inc_not_zero(&sk->sk_refcnt)) 259 258 sk = NULL;

+1 -2

net/ipv6/netfilter/nf_socket_ipv6.c

reviewed

··· 83 83 { 84 84 switch (protocol) { 85 85 case IPPROTO_TCP: 86 86 - return inet6_lookup(net, net->ipv4.tcp_death_row.hashinfo, 87 87 - skb, doff, saddr, sport, daddr, dport, 86 86 + return inet6_lookup(net, skb, doff, saddr, sport, daddr, dport, 88 87 in->ifindex); 89 88 case IPPROTO_UDP: 90 89 return udp6_lib_lookup(net, saddr, sport, daddr, dport,

+2 -3

net/ipv6/netfilter/nf_tproxy_ipv6.c

reviewed

··· 80 80 const struct net_device *in, 81 81 const enum nf_tproxy_lookup_t lookup_type) 82 82 { 83 83 - struct inet_hashinfo *hinfo = net->ipv4.tcp_death_row.hashinfo; 84 83 struct sock *sk; 85 84 86 85 switch (protocol) { ··· 93 94 94 95 switch (lookup_type) { 95 96 case NF_TPROXY_LOOKUP_LISTENER: 96 96 - sk = inet6_lookup_listener(net, hinfo, skb, 97 97 + sk = inet6_lookup_listener(net, skb, 97 98 thoff + __tcp_hdrlen(hp), 98 99 saddr, sport, 99 100 daddr, ntohs(dport), ··· 108 109 */ 109 110 break; 110 111 case NF_TPROXY_LOOKUP_ESTABLISHED: 111 111 - sk = __inet6_lookup_established(net, hinfo, saddr, sport, daddr, 112 112 + sk = __inet6_lookup_established(net, saddr, sport, daddr, 112 113 ntohs(dport), in->ifindex, 0); 113 114 break; 114 115 default:

+5 -9

net/ipv6/tcp_ipv6.c

reviewed

··· 388 388 bool fatal; 389 389 int err; 390 390 391 391 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 392 392 - &hdr->daddr, th->dest, 391 391 + sk = __inet6_lookup_established(net, &hdr->daddr, th->dest, 393 392 &hdr->saddr, ntohs(th->source), 394 393 skb->dev->ifindex, inet6_sdif(skb)); 395 394 ··· 1072 1073 * Incoming packet is checked with md5 hash with finding key, 1073 1074 * no RST generated if md5 hash doesn't match. 1074 1075 */ 1075 1075 - sk1 = inet6_lookup_listener(net, net->ipv4.tcp_death_row.hashinfo, 1076 1076 - NULL, 0, &ipv6h->saddr, th->source, 1076 1076 + sk1 = inet6_lookup_listener(net, NULL, 0, &ipv6h->saddr, th->source, 1077 1077 &ipv6h->daddr, ntohs(th->source), 1078 1078 dif, sdif); 1079 1079 if (!sk1) ··· 1787 1789 hdr = ipv6_hdr(skb); 1788 1790 1789 1791 lookup: 1790 1790 - sk = __inet6_lookup_skb(net->ipv4.tcp_death_row.hashinfo, skb, __tcp_hdrlen(th), 1792 1792 + sk = __inet6_lookup_skb(skb, __tcp_hdrlen(th), 1791 1793 th->source, th->dest, inet6_iif(skb), sdif, 1792 1794 &refcounted); 1793 1795 if (!sk) ··· 1974 1976 { 1975 1977 struct sock *sk2; 1976 1978 1977 1977 - sk2 = inet6_lookup_listener(net, net->ipv4.tcp_death_row.hashinfo, 1978 1978 - skb, __tcp_hdrlen(th), 1979 1979 + sk2 = inet6_lookup_listener(net, skb, __tcp_hdrlen(th), 1979 1980 &ipv6_hdr(skb)->saddr, th->source, 1980 1981 &ipv6_hdr(skb)->daddr, 1981 1982 ntohs(th->dest), ··· 2026 2029 return; 2027 2030 2028 2031 /* Note : We use inet6_iif() here, not tcp_v6_iif() */ 2029 2029 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 2030 2030 - &hdr->saddr, th->source, 2032 2032 + sk = __inet6_lookup_established(net, &hdr->saddr, th->source, 2031 2033 &hdr->daddr, ntohs(th->dest), 2032 2034 inet6_iif(skb), inet6_sdif(skb)); 2033 2035 if (sk) {

+1 -2

net/ipv6/tcpv6_offload.c

reviewed

··· 36 36 inet6_get_iif_sdif(skb, &iif, &sdif); 37 37 hdr = skb_gro_network_header(skb); 38 38 net = dev_net_rcu(skb->dev); 39 39 - sk = __inet6_lookup_established(net, net->ipv4.tcp_death_row.hashinfo, 40 40 - &hdr->saddr, th->source, 39 39 + sk = __inet6_lookup_established(net, &hdr->saddr, th->source, 41 40 &hdr->daddr, ntohs(th->dest), 42 41 iif, sdif); 43 42 NAPI_GRO_CB(skb)->is_flist = !sk;