PageRenderTime 125ms CodeModel.GetById 13ms app.highlight 96ms RepoModel.GetById 1ms app.codeStats 1ms

/net/ipv4/udp.c

http://github.com/mirrors/linux
C | 3087 lines | 2238 code | 420 blank | 429 comment | 476 complexity | b9e9ebc4d37fda98aee45bb53c4ba105 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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 *		The User Datagram Protocol (UDP).
   8 *
   9 * Authors:	Ross Biro
  10 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  11 *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  12 *		Alan Cox, <alan@lxorguk.ukuu.org.uk>
  13 *		Hirokazu Takahashi, <taka@valinux.co.jp>
  14 *
  15 * Fixes:
  16 *		Alan Cox	:	verify_area() calls
  17 *		Alan Cox	: 	stopped close while in use off icmp
  18 *					messages. Not a fix but a botch that
  19 *					for udp at least is 'valid'.
  20 *		Alan Cox	:	Fixed icmp handling properly
  21 *		Alan Cox	: 	Correct error for oversized datagrams
  22 *		Alan Cox	:	Tidied select() semantics.
  23 *		Alan Cox	:	udp_err() fixed properly, also now
  24 *					select and read wake correctly on errors
  25 *		Alan Cox	:	udp_send verify_area moved to avoid mem leak
  26 *		Alan Cox	:	UDP can count its memory
  27 *		Alan Cox	:	send to an unknown connection causes
  28 *					an ECONNREFUSED off the icmp, but
  29 *					does NOT close.
  30 *		Alan Cox	:	Switched to new sk_buff handlers. No more backlog!
  31 *		Alan Cox	:	Using generic datagram code. Even smaller and the PEEK
  32 *					bug no longer crashes it.
  33 *		Fred Van Kempen	: 	Net2e support for sk->broadcast.
  34 *		Alan Cox	:	Uses skb_free_datagram
  35 *		Alan Cox	:	Added get/set sockopt support.
  36 *		Alan Cox	:	Broadcasting without option set returns EACCES.
  37 *		Alan Cox	:	No wakeup calls. Instead we now use the callbacks.
  38 *		Alan Cox	:	Use ip_tos and ip_ttl
  39 *		Alan Cox	:	SNMP Mibs
  40 *		Alan Cox	:	MSG_DONTROUTE, and 0.0.0.0 support.
  41 *		Matt Dillon	:	UDP length checks.
  42 *		Alan Cox	:	Smarter af_inet used properly.
  43 *		Alan Cox	:	Use new kernel side addressing.
  44 *		Alan Cox	:	Incorrect return on truncated datagram receive.
  45 *	Arnt Gulbrandsen 	:	New udp_send and stuff
  46 *		Alan Cox	:	Cache last socket
  47 *		Alan Cox	:	Route cache
  48 *		Jon Peatfield	:	Minor efficiency fix to sendto().
  49 *		Mike Shaver	:	RFC1122 checks.
  50 *		Alan Cox	:	Nonblocking error fix.
  51 *	Willy Konynenberg	:	Transparent proxying support.
  52 *		Mike McLagan	:	Routing by source
  53 *		David S. Miller	:	New socket lookup architecture.
  54 *					Last socket cache retained as it
  55 *					does have a high hit rate.
  56 *		Olaf Kirch	:	Don't linearise iovec on sendmsg.
  57 *		Andi Kleen	:	Some cleanups, cache destination entry
  58 *					for connect.
  59 *	Vitaly E. Lavrov	:	Transparent proxy revived after year coma.
  60 *		Melvin Smith	:	Check msg_name not msg_namelen in sendto(),
  61 *					return ENOTCONN for unconnected sockets (POSIX)
  62 *		Janos Farkas	:	don't deliver multi/broadcasts to a different
  63 *					bound-to-device socket
  64 *	Hirokazu Takahashi	:	HW checksumming for outgoing UDP
  65 *					datagrams.
  66 *	Hirokazu Takahashi	:	sendfile() on UDP works now.
  67 *		Arnaldo C. Melo :	convert /proc/net/udp to seq_file
  68 *	YOSHIFUJI Hideaki @USAGI and:	Support IPV6_V6ONLY socket option, which
  69 *	Alexey Kuznetsov:		allow both IPv4 and IPv6 sockets to bind
  70 *					a single port at the same time.
  71 *	Derek Atkins <derek@ihtfp.com>: Add Encapulation Support
  72 *	James Chapman		:	Add L2TP encapsulation type.
  73 */
  74
  75#define pr_fmt(fmt) "UDP: " fmt
  76
  77#include <linux/uaccess.h>
  78#include <asm/ioctls.h>
  79#include <linux/memblock.h>
  80#include <linux/highmem.h>
  81#include <linux/swap.h>
  82#include <linux/types.h>
  83#include <linux/fcntl.h>
  84#include <linux/module.h>
  85#include <linux/socket.h>
  86#include <linux/sockios.h>
  87#include <linux/igmp.h>
  88#include <linux/inetdevice.h>
  89#include <linux/in.h>
  90#include <linux/errno.h>
  91#include <linux/timer.h>
  92#include <linux/mm.h>
  93#include <linux/inet.h>
  94#include <linux/netdevice.h>
  95#include <linux/slab.h>
  96#include <net/tcp_states.h>
  97#include <linux/skbuff.h>
  98#include <linux/proc_fs.h>
  99#include <linux/seq_file.h>
 100#include <net/net_namespace.h>
 101#include <net/icmp.h>
 102#include <net/inet_hashtables.h>
 103#include <net/ip_tunnels.h>
 104#include <net/route.h>
 105#include <net/checksum.h>
 106#include <net/xfrm.h>
 107#include <trace/events/udp.h>
 108#include <linux/static_key.h>
 109#include <trace/events/skb.h>
 110#include <net/busy_poll.h>
 111#include "udp_impl.h"
 112#include <net/sock_reuseport.h>
 113#include <net/addrconf.h>
 114#include <net/udp_tunnel.h>
 115
 116struct udp_table udp_table __read_mostly;
 117EXPORT_SYMBOL(udp_table);
 118
 119long sysctl_udp_mem[3] __read_mostly;
 120EXPORT_SYMBOL(sysctl_udp_mem);
 121
 122atomic_long_t udp_memory_allocated;
 123EXPORT_SYMBOL(udp_memory_allocated);
 124
 125#define MAX_UDP_PORTS 65536
 126#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
 127
 128static int udp_lib_lport_inuse(struct net *net, __u16 num,
 129			       const struct udp_hslot *hslot,
 130			       unsigned long *bitmap,
 131			       struct sock *sk, unsigned int log)
 132{
 133	struct sock *sk2;
 134	kuid_t uid = sock_i_uid(sk);
 135
 136	sk_for_each(sk2, &hslot->head) {
 137		if (net_eq(sock_net(sk2), net) &&
 138		    sk2 != sk &&
 139		    (bitmap || udp_sk(sk2)->udp_port_hash == num) &&
 140		    (!sk2->sk_reuse || !sk->sk_reuse) &&
 141		    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
 142		     sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
 143		    inet_rcv_saddr_equal(sk, sk2, true)) {
 144			if (sk2->sk_reuseport && sk->sk_reuseport &&
 145			    !rcu_access_pointer(sk->sk_reuseport_cb) &&
 146			    uid_eq(uid, sock_i_uid(sk2))) {
 147				if (!bitmap)
 148					return 0;
 149			} else {
 150				if (!bitmap)
 151					return 1;
 152				__set_bit(udp_sk(sk2)->udp_port_hash >> log,
 153					  bitmap);
 154			}
 155		}
 156	}
 157	return 0;
 158}
 159
 160/*
 161 * Note: we still hold spinlock of primary hash chain, so no other writer
 162 * can insert/delete a socket with local_port == num
 163 */
 164static int udp_lib_lport_inuse2(struct net *net, __u16 num,
 165				struct udp_hslot *hslot2,
 166				struct sock *sk)
 167{
 168	struct sock *sk2;
 169	kuid_t uid = sock_i_uid(sk);
 170	int res = 0;
 171
 172	spin_lock(&hslot2->lock);
 173	udp_portaddr_for_each_entry(sk2, &hslot2->head) {
 174		if (net_eq(sock_net(sk2), net) &&
 175		    sk2 != sk &&
 176		    (udp_sk(sk2)->udp_port_hash == num) &&
 177		    (!sk2->sk_reuse || !sk->sk_reuse) &&
 178		    (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if ||
 179		     sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
 180		    inet_rcv_saddr_equal(sk, sk2, true)) {
 181			if (sk2->sk_reuseport && sk->sk_reuseport &&
 182			    !rcu_access_pointer(sk->sk_reuseport_cb) &&
 183			    uid_eq(uid, sock_i_uid(sk2))) {
 184				res = 0;
 185			} else {
 186				res = 1;
 187			}
 188			break;
 189		}
 190	}
 191	spin_unlock(&hslot2->lock);
 192	return res;
 193}
 194
 195static int udp_reuseport_add_sock(struct sock *sk, struct udp_hslot *hslot)
 196{
 197	struct net *net = sock_net(sk);
 198	kuid_t uid = sock_i_uid(sk);
 199	struct sock *sk2;
 200
 201	sk_for_each(sk2, &hslot->head) {
 202		if (net_eq(sock_net(sk2), net) &&
 203		    sk2 != sk &&
 204		    sk2->sk_family == sk->sk_family &&
 205		    ipv6_only_sock(sk2) == ipv6_only_sock(sk) &&
 206		    (udp_sk(sk2)->udp_port_hash == udp_sk(sk)->udp_port_hash) &&
 207		    (sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
 208		    sk2->sk_reuseport && uid_eq(uid, sock_i_uid(sk2)) &&
 209		    inet_rcv_saddr_equal(sk, sk2, false)) {
 210			return reuseport_add_sock(sk, sk2,
 211						  inet_rcv_saddr_any(sk));
 212		}
 213	}
 214
 215	return reuseport_alloc(sk, inet_rcv_saddr_any(sk));
 216}
 217
 218/**
 219 *  udp_lib_get_port  -  UDP/-Lite port lookup for IPv4 and IPv6
 220 *
 221 *  @sk:          socket struct in question
 222 *  @snum:        port number to look up
 223 *  @hash2_nulladdr: AF-dependent hash value in secondary hash chains,
 224 *                   with NULL address
 225 */
 226int udp_lib_get_port(struct sock *sk, unsigned short snum,
 227		     unsigned int hash2_nulladdr)
 228{
 229	struct udp_hslot *hslot, *hslot2;
 230	struct udp_table *udptable = sk->sk_prot->h.udp_table;
 231	int    error = 1;
 232	struct net *net = sock_net(sk);
 233
 234	if (!snum) {
 235		int low, high, remaining;
 236		unsigned int rand;
 237		unsigned short first, last;
 238		DECLARE_BITMAP(bitmap, PORTS_PER_CHAIN);
 239
 240		inet_get_local_port_range(net, &low, &high);
 241		remaining = (high - low) + 1;
 242
 243		rand = prandom_u32();
 244		first = reciprocal_scale(rand, remaining) + low;
 245		/*
 246		 * force rand to be an odd multiple of UDP_HTABLE_SIZE
 247		 */
 248		rand = (rand | 1) * (udptable->mask + 1);
 249		last = first + udptable->mask + 1;
 250		do {
 251			hslot = udp_hashslot(udptable, net, first);
 252			bitmap_zero(bitmap, PORTS_PER_CHAIN);
 253			spin_lock_bh(&hslot->lock);
 254			udp_lib_lport_inuse(net, snum, hslot, bitmap, sk,
 255					    udptable->log);
 256
 257			snum = first;
 258			/*
 259			 * Iterate on all possible values of snum for this hash.
 260			 * Using steps of an odd multiple of UDP_HTABLE_SIZE
 261			 * give us randomization and full range coverage.
 262			 */
 263			do {
 264				if (low <= snum && snum <= high &&
 265				    !test_bit(snum >> udptable->log, bitmap) &&
 266				    !inet_is_local_reserved_port(net, snum))
 267					goto found;
 268				snum += rand;
 269			} while (snum != first);
 270			spin_unlock_bh(&hslot->lock);
 271			cond_resched();
 272		} while (++first != last);
 273		goto fail;
 274	} else {
 275		hslot = udp_hashslot(udptable, net, snum);
 276		spin_lock_bh(&hslot->lock);
 277		if (hslot->count > 10) {
 278			int exist;
 279			unsigned int slot2 = udp_sk(sk)->udp_portaddr_hash ^ snum;
 280
 281			slot2          &= udptable->mask;
 282			hash2_nulladdr &= udptable->mask;
 283
 284			hslot2 = udp_hashslot2(udptable, slot2);
 285			if (hslot->count < hslot2->count)
 286				goto scan_primary_hash;
 287
 288			exist = udp_lib_lport_inuse2(net, snum, hslot2, sk);
 289			if (!exist && (hash2_nulladdr != slot2)) {
 290				hslot2 = udp_hashslot2(udptable, hash2_nulladdr);
 291				exist = udp_lib_lport_inuse2(net, snum, hslot2,
 292							     sk);
 293			}
 294			if (exist)
 295				goto fail_unlock;
 296			else
 297				goto found;
 298		}
 299scan_primary_hash:
 300		if (udp_lib_lport_inuse(net, snum, hslot, NULL, sk, 0))
 301			goto fail_unlock;
 302	}
 303found:
 304	inet_sk(sk)->inet_num = snum;
 305	udp_sk(sk)->udp_port_hash = snum;
 306	udp_sk(sk)->udp_portaddr_hash ^= snum;
 307	if (sk_unhashed(sk)) {
 308		if (sk->sk_reuseport &&
 309		    udp_reuseport_add_sock(sk, hslot)) {
 310			inet_sk(sk)->inet_num = 0;
 311			udp_sk(sk)->udp_port_hash = 0;
 312			udp_sk(sk)->udp_portaddr_hash ^= snum;
 313			goto fail_unlock;
 314		}
 315
 316		sk_add_node_rcu(sk, &hslot->head);
 317		hslot->count++;
 318		sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
 319
 320		hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
 321		spin_lock(&hslot2->lock);
 322		if (IS_ENABLED(CONFIG_IPV6) && sk->sk_reuseport &&
 323		    sk->sk_family == AF_INET6)
 324			hlist_add_tail_rcu(&udp_sk(sk)->udp_portaddr_node,
 325					   &hslot2->head);
 326		else
 327			hlist_add_head_rcu(&udp_sk(sk)->udp_portaddr_node,
 328					   &hslot2->head);
 329		hslot2->count++;
 330		spin_unlock(&hslot2->lock);
 331	}
 332	sock_set_flag(sk, SOCK_RCU_FREE);
 333	error = 0;
 334fail_unlock:
 335	spin_unlock_bh(&hslot->lock);
 336fail:
 337	return error;
 338}
 339EXPORT_SYMBOL(udp_lib_get_port);
 340
 341int udp_v4_get_port(struct sock *sk, unsigned short snum)
 342{
 343	unsigned int hash2_nulladdr =
 344		ipv4_portaddr_hash(sock_net(sk), htonl(INADDR_ANY), snum);
 345	unsigned int hash2_partial =
 346		ipv4_portaddr_hash(sock_net(sk), inet_sk(sk)->inet_rcv_saddr, 0);
 347
 348	/* precompute partial secondary hash */
 349	udp_sk(sk)->udp_portaddr_hash = hash2_partial;
 350	return udp_lib_get_port(sk, snum, hash2_nulladdr);
 351}
 352
 353static int compute_score(struct sock *sk, struct net *net,
 354			 __be32 saddr, __be16 sport,
 355			 __be32 daddr, unsigned short hnum,
 356			 int dif, int sdif)
 357{
 358	int score;
 359	struct inet_sock *inet;
 360	bool dev_match;
 361
 362	if (!net_eq(sock_net(sk), net) ||
 363	    udp_sk(sk)->udp_port_hash != hnum ||
 364	    ipv6_only_sock(sk))
 365		return -1;
 366
 367	if (sk->sk_rcv_saddr != daddr)
 368		return -1;
 369
 370	score = (sk->sk_family == PF_INET) ? 2 : 1;
 371
 372	inet = inet_sk(sk);
 373	if (inet->inet_daddr) {
 374		if (inet->inet_daddr != saddr)
 375			return -1;
 376		score += 4;
 377	}
 378
 379	if (inet->inet_dport) {
 380		if (inet->inet_dport != sport)
 381			return -1;
 382		score += 4;
 383	}
 384
 385	dev_match = udp_sk_bound_dev_eq(net, sk->sk_bound_dev_if,
 386					dif, sdif);
 387	if (!dev_match)
 388		return -1;
 389	score += 4;
 390
 391	if (READ_ONCE(sk->sk_incoming_cpu) == raw_smp_processor_id())
 392		score++;
 393	return score;
 394}
 395
 396static u32 udp_ehashfn(const struct net *net, const __be32 laddr,
 397		       const __u16 lport, const __be32 faddr,
 398		       const __be16 fport)
 399{
 400	static u32 udp_ehash_secret __read_mostly;
 401
 402	net_get_random_once(&udp_ehash_secret, sizeof(udp_ehash_secret));
 403
 404	return __inet_ehashfn(laddr, lport, faddr, fport,
 405			      udp_ehash_secret + net_hash_mix(net));
 406}
 407
 408/* called with rcu_read_lock() */
 409static struct sock *udp4_lib_lookup2(struct net *net,
 410				     __be32 saddr, __be16 sport,
 411				     __be32 daddr, unsigned int hnum,
 412				     int dif, int sdif,
 413				     struct udp_hslot *hslot2,
 414				     struct sk_buff *skb)
 415{
 416	struct sock *sk, *result;
 417	int score, badness;
 418	u32 hash = 0;
 419
 420	result = NULL;
 421	badness = 0;
 422	udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) {
 423		score = compute_score(sk, net, saddr, sport,
 424				      daddr, hnum, dif, sdif);
 425		if (score > badness) {
 426			if (sk->sk_reuseport &&
 427			    sk->sk_state != TCP_ESTABLISHED) {
 428				hash = udp_ehashfn(net, daddr, hnum,
 429						   saddr, sport);
 430				result = reuseport_select_sock(sk, hash, skb,
 431							sizeof(struct udphdr));
 432				if (result && !reuseport_has_conns(sk, false))
 433					return result;
 434			}
 435			badness = score;
 436			result = sk;
 437		}
 438	}
 439	return result;
 440}
 441
 442/* UDP is nearly always wildcards out the wazoo, it makes no sense to try
 443 * harder than this. -DaveM
 444 */
 445struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
 446		__be16 sport, __be32 daddr, __be16 dport, int dif,
 447		int sdif, struct udp_table *udptable, struct sk_buff *skb)
 448{
 449	struct sock *result;
 450	unsigned short hnum = ntohs(dport);
 451	unsigned int hash2, slot2;
 452	struct udp_hslot *hslot2;
 453
 454	hash2 = ipv4_portaddr_hash(net, daddr, hnum);
 455	slot2 = hash2 & udptable->mask;
 456	hslot2 = &udptable->hash2[slot2];
 457
 458	result = udp4_lib_lookup2(net, saddr, sport,
 459				  daddr, hnum, dif, sdif,
 460				  hslot2, skb);
 461	if (!result) {
 462		hash2 = ipv4_portaddr_hash(net, htonl(INADDR_ANY), hnum);
 463		slot2 = hash2 & udptable->mask;
 464		hslot2 = &udptable->hash2[slot2];
 465
 466		result = udp4_lib_lookup2(net, saddr, sport,
 467					  htonl(INADDR_ANY), hnum, dif, sdif,
 468					  hslot2, skb);
 469	}
 470	if (IS_ERR(result))
 471		return NULL;
 472	return result;
 473}
 474EXPORT_SYMBOL_GPL(__udp4_lib_lookup);
 475
 476static inline struct sock *__udp4_lib_lookup_skb(struct sk_buff *skb,
 477						 __be16 sport, __be16 dport,
 478						 struct udp_table *udptable)
 479{
 480	const struct iphdr *iph = ip_hdr(skb);
 481
 482	return __udp4_lib_lookup(dev_net(skb->dev), iph->saddr, sport,
 483				 iph->daddr, dport, inet_iif(skb),
 484				 inet_sdif(skb), udptable, skb);
 485}
 486
 487struct sock *udp4_lib_lookup_skb(struct sk_buff *skb,
 488				 __be16 sport, __be16 dport)
 489{
 490	const struct iphdr *iph = ip_hdr(skb);
 491
 492	return __udp4_lib_lookup(dev_net(skb->dev), iph->saddr, sport,
 493				 iph->daddr, dport, inet_iif(skb),
 494				 inet_sdif(skb), &udp_table, NULL);
 495}
 496EXPORT_SYMBOL_GPL(udp4_lib_lookup_skb);
 497
 498/* Must be called under rcu_read_lock().
 499 * Does increment socket refcount.
 500 */
 501#if IS_ENABLED(CONFIG_NF_TPROXY_IPV4) || IS_ENABLED(CONFIG_NF_SOCKET_IPV4)
 502struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport,
 503			     __be32 daddr, __be16 dport, int dif)
 504{
 505	struct sock *sk;
 506
 507	sk = __udp4_lib_lookup(net, saddr, sport, daddr, dport,
 508			       dif, 0, &udp_table, NULL);
 509	if (sk && !refcount_inc_not_zero(&sk->sk_refcnt))
 510		sk = NULL;
 511	return sk;
 512}
 513EXPORT_SYMBOL_GPL(udp4_lib_lookup);
 514#endif
 515
 516static inline bool __udp_is_mcast_sock(struct net *net, struct sock *sk,
 517				       __be16 loc_port, __be32 loc_addr,
 518				       __be16 rmt_port, __be32 rmt_addr,
 519				       int dif, int sdif, unsigned short hnum)
 520{
 521	struct inet_sock *inet = inet_sk(sk);
 522
 523	if (!net_eq(sock_net(sk), net) ||
 524	    udp_sk(sk)->udp_port_hash != hnum ||
 525	    (inet->inet_daddr && inet->inet_daddr != rmt_addr) ||
 526	    (inet->inet_dport != rmt_port && inet->inet_dport) ||
 527	    (inet->inet_rcv_saddr && inet->inet_rcv_saddr != loc_addr) ||
 528	    ipv6_only_sock(sk) ||
 529	    !udp_sk_bound_dev_eq(net, sk->sk_bound_dev_if, dif, sdif))
 530		return false;
 531	if (!ip_mc_sf_allow(sk, loc_addr, rmt_addr, dif, sdif))
 532		return false;
 533	return true;
 534}
 535
 536DEFINE_STATIC_KEY_FALSE(udp_encap_needed_key);
 537void udp_encap_enable(void)
 538{
 539	static_branch_inc(&udp_encap_needed_key);
 540}
 541EXPORT_SYMBOL(udp_encap_enable);
 542
 543/* Handler for tunnels with arbitrary destination ports: no socket lookup, go
 544 * through error handlers in encapsulations looking for a match.
 545 */
 546static int __udp4_lib_err_encap_no_sk(struct sk_buff *skb, u32 info)
 547{
 548	int i;
 549
 550	for (i = 0; i < MAX_IPTUN_ENCAP_OPS; i++) {
 551		int (*handler)(struct sk_buff *skb, u32 info);
 552		const struct ip_tunnel_encap_ops *encap;
 553
 554		encap = rcu_dereference(iptun_encaps[i]);
 555		if (!encap)
 556			continue;
 557		handler = encap->err_handler;
 558		if (handler && !handler(skb, info))
 559			return 0;
 560	}
 561
 562	return -ENOENT;
 563}
 564
 565/* Try to match ICMP errors to UDP tunnels by looking up a socket without
 566 * reversing source and destination port: this will match tunnels that force the
 567 * same destination port on both endpoints (e.g. VXLAN, GENEVE). Note that
 568 * lwtunnels might actually break this assumption by being configured with
 569 * different destination ports on endpoints, in this case we won't be able to
 570 * trace ICMP messages back to them.
 571 *
 572 * If this doesn't match any socket, probe tunnels with arbitrary destination
 573 * ports (e.g. FoU, GUE): there, the receiving socket is useless, as the port
 574 * we've sent packets to won't necessarily match the local destination port.
 575 *
 576 * Then ask the tunnel implementation to match the error against a valid
 577 * association.
 578 *
 579 * Return an error if we can't find a match, the socket if we need further
 580 * processing, zero otherwise.
 581 */
 582static struct sock *__udp4_lib_err_encap(struct net *net,
 583					 const struct iphdr *iph,
 584					 struct udphdr *uh,
 585					 struct udp_table *udptable,
 586					 struct sk_buff *skb, u32 info)
 587{
 588	int network_offset, transport_offset;
 589	struct sock *sk;
 590
 591	network_offset = skb_network_offset(skb);
 592	transport_offset = skb_transport_offset(skb);
 593
 594	/* Network header needs to point to the outer IPv4 header inside ICMP */
 595	skb_reset_network_header(skb);
 596
 597	/* Transport header needs to point to the UDP header */
 598	skb_set_transport_header(skb, iph->ihl << 2);
 599
 600	sk = __udp4_lib_lookup(net, iph->daddr, uh->source,
 601			       iph->saddr, uh->dest, skb->dev->ifindex, 0,
 602			       udptable, NULL);
 603	if (sk) {
 604		int (*lookup)(struct sock *sk, struct sk_buff *skb);
 605		struct udp_sock *up = udp_sk(sk);
 606
 607		lookup = READ_ONCE(up->encap_err_lookup);
 608		if (!lookup || lookup(sk, skb))
 609			sk = NULL;
 610	}
 611
 612	if (!sk)
 613		sk = ERR_PTR(__udp4_lib_err_encap_no_sk(skb, info));
 614
 615	skb_set_transport_header(skb, transport_offset);
 616	skb_set_network_header(skb, network_offset);
 617
 618	return sk;
 619}
 620
 621/*
 622 * This routine is called by the ICMP module when it gets some
 623 * sort of error condition.  If err < 0 then the socket should
 624 * be closed and the error returned to the user.  If err > 0
 625 * it's just the icmp type << 8 | icmp code.
 626 * Header points to the ip header of the error packet. We move
 627 * on past this. Then (as it used to claim before adjustment)
 628 * header points to the first 8 bytes of the udp header.  We need
 629 * to find the appropriate port.
 630 */
 631
 632int __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
 633{
 634	struct inet_sock *inet;
 635	const struct iphdr *iph = (const struct iphdr *)skb->data;
 636	struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
 637	const int type = icmp_hdr(skb)->type;
 638	const int code = icmp_hdr(skb)->code;
 639	bool tunnel = false;
 640	struct sock *sk;
 641	int harderr;
 642	int err;
 643	struct net *net = dev_net(skb->dev);
 644
 645	sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,
 646			       iph->saddr, uh->source, skb->dev->ifindex,
 647			       inet_sdif(skb), udptable, NULL);
 648	if (!sk) {
 649		/* No socket for error: try tunnels before discarding */
 650		sk = ERR_PTR(-ENOENT);
 651		if (static_branch_unlikely(&udp_encap_needed_key)) {
 652			sk = __udp4_lib_err_encap(net, iph, uh, udptable, skb,
 653						  info);
 654			if (!sk)
 655				return 0;
 656		}
 657
 658		if (IS_ERR(sk)) {
 659			__ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
 660			return PTR_ERR(sk);
 661		}
 662
 663		tunnel = true;
 664	}
 665
 666	err = 0;
 667	harderr = 0;
 668	inet = inet_sk(sk);
 669
 670	switch (type) {
 671	default:
 672	case ICMP_TIME_EXCEEDED:
 673		err = EHOSTUNREACH;
 674		break;
 675	case ICMP_SOURCE_QUENCH:
 676		goto out;
 677	case ICMP_PARAMETERPROB:
 678		err = EPROTO;
 679		harderr = 1;
 680		break;
 681	case ICMP_DEST_UNREACH:
 682		if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
 683			ipv4_sk_update_pmtu(skb, sk, info);
 684			if (inet->pmtudisc != IP_PMTUDISC_DONT) {
 685				err = EMSGSIZE;
 686				harderr = 1;
 687				break;
 688			}
 689			goto out;
 690		}
 691		err = EHOSTUNREACH;
 692		if (code <= NR_ICMP_UNREACH) {
 693			harderr = icmp_err_convert[code].fatal;
 694			err = icmp_err_convert[code].errno;
 695		}
 696		break;
 697	case ICMP_REDIRECT:
 698		ipv4_sk_redirect(skb, sk);
 699		goto out;
 700	}
 701
 702	/*
 703	 *      RFC1122: OK.  Passes ICMP errors back to application, as per
 704	 *	4.1.3.3.
 705	 */
 706	if (tunnel) {
 707		/* ...not for tunnels though: we don't have a sending socket */
 708		goto out;
 709	}
 710	if (!inet->recverr) {
 711		if (!harderr || sk->sk_state != TCP_ESTABLISHED)
 712			goto out;
 713	} else
 714		ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
 715
 716	sk->sk_err = err;
 717	sk->sk_error_report(sk);
 718out:
 719	return 0;
 720}
 721
 722int udp_err(struct sk_buff *skb, u32 info)
 723{
 724	return __udp4_lib_err(skb, info, &udp_table);
 725}
 726
 727/*
 728 * Throw away all pending data and cancel the corking. Socket is locked.
 729 */
 730void udp_flush_pending_frames(struct sock *sk)
 731{
 732	struct udp_sock *up = udp_sk(sk);
 733
 734	if (up->pending) {
 735		up->len = 0;
 736		up->pending = 0;
 737		ip_flush_pending_frames(sk);
 738	}
 739}
 740EXPORT_SYMBOL(udp_flush_pending_frames);
 741
 742/**
 743 * 	udp4_hwcsum  -  handle outgoing HW checksumming
 744 * 	@skb: 	sk_buff containing the filled-in UDP header
 745 * 	        (checksum field must be zeroed out)
 746 *	@src:	source IP address
 747 *	@dst:	destination IP address
 748 */
 749void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst)
 750{
 751	struct udphdr *uh = udp_hdr(skb);
 752	int offset = skb_transport_offset(skb);
 753	int len = skb->len - offset;
 754	int hlen = len;
 755	__wsum csum = 0;
 756
 757	if (!skb_has_frag_list(skb)) {
 758		/*
 759		 * Only one fragment on the socket.
 760		 */
 761		skb->csum_start = skb_transport_header(skb) - skb->head;
 762		skb->csum_offset = offsetof(struct udphdr, check);
 763		uh->check = ~csum_tcpudp_magic(src, dst, len,
 764					       IPPROTO_UDP, 0);
 765	} else {
 766		struct sk_buff *frags;
 767
 768		/*
 769		 * HW-checksum won't work as there are two or more
 770		 * fragments on the socket so that all csums of sk_buffs
 771		 * should be together
 772		 */
 773		skb_walk_frags(skb, frags) {
 774			csum = csum_add(csum, frags->csum);
 775			hlen -= frags->len;
 776		}
 777
 778		csum = skb_checksum(skb, offset, hlen, csum);
 779		skb->ip_summed = CHECKSUM_NONE;
 780
 781		uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
 782		if (uh->check == 0)
 783			uh->check = CSUM_MANGLED_0;
 784	}
 785}
 786EXPORT_SYMBOL_GPL(udp4_hwcsum);
 787
 788/* Function to set UDP checksum for an IPv4 UDP packet. This is intended
 789 * for the simple case like when setting the checksum for a UDP tunnel.
 790 */
 791void udp_set_csum(bool nocheck, struct sk_buff *skb,
 792		  __be32 saddr, __be32 daddr, int len)
 793{
 794	struct udphdr *uh = udp_hdr(skb);
 795
 796	if (nocheck) {
 797		uh->check = 0;
 798	} else if (skb_is_gso(skb)) {
 799		uh->check = ~udp_v4_check(len, saddr, daddr, 0);
 800	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 801		uh->check = 0;
 802		uh->check = udp_v4_check(len, saddr, daddr, lco_csum(skb));
 803		if (uh->check == 0)
 804			uh->check = CSUM_MANGLED_0;
 805	} else {
 806		skb->ip_summed = CHECKSUM_PARTIAL;
 807		skb->csum_start = skb_transport_header(skb) - skb->head;
 808		skb->csum_offset = offsetof(struct udphdr, check);
 809		uh->check = ~udp_v4_check(len, saddr, daddr, 0);
 810	}
 811}
 812EXPORT_SYMBOL(udp_set_csum);
 813
 814static int udp_send_skb(struct sk_buff *skb, struct flowi4 *fl4,
 815			struct inet_cork *cork)
 816{
 817	struct sock *sk = skb->sk;
 818	struct inet_sock *inet = inet_sk(sk);
 819	struct udphdr *uh;
 820	int err = 0;
 821	int is_udplite = IS_UDPLITE(sk);
 822	int offset = skb_transport_offset(skb);
 823	int len = skb->len - offset;
 824	int datalen = len - sizeof(*uh);
 825	__wsum csum = 0;
 826
 827	/*
 828	 * Create a UDP header
 829	 */
 830	uh = udp_hdr(skb);
 831	uh->source = inet->inet_sport;
 832	uh->dest = fl4->fl4_dport;
 833	uh->len = htons(len);
 834	uh->check = 0;
 835
 836	if (cork->gso_size) {
 837		const int hlen = skb_network_header_len(skb) +
 838				 sizeof(struct udphdr);
 839
 840		if (hlen + cork->gso_size > cork->fragsize) {
 841			kfree_skb(skb);
 842			return -EINVAL;
 843		}
 844		if (skb->len > cork->gso_size * UDP_MAX_SEGMENTS) {
 845			kfree_skb(skb);
 846			return -EINVAL;
 847		}
 848		if (sk->sk_no_check_tx) {
 849			kfree_skb(skb);
 850			return -EINVAL;
 851		}
 852		if (skb->ip_summed != CHECKSUM_PARTIAL || is_udplite ||
 853		    dst_xfrm(skb_dst(skb))) {
 854			kfree_skb(skb);
 855			return -EIO;
 856		}
 857
 858		if (datalen > cork->gso_size) {
 859			skb_shinfo(skb)->gso_size = cork->gso_size;
 860			skb_shinfo(skb)->gso_type = SKB_GSO_UDP_L4;
 861			skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(datalen,
 862								 cork->gso_size);
 863		}
 864		goto csum_partial;
 865	}
 866
 867	if (is_udplite)  				 /*     UDP-Lite      */
 868		csum = udplite_csum(skb);
 869
 870	else if (sk->sk_no_check_tx) {			 /* UDP csum off */
 871
 872		skb->ip_summed = CHECKSUM_NONE;
 873		goto send;
 874
 875	} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
 876csum_partial:
 877
 878		udp4_hwcsum(skb, fl4->saddr, fl4->daddr);
 879		goto send;
 880
 881	} else
 882		csum = udp_csum(skb);
 883
 884	/* add protocol-dependent pseudo-header */
 885	uh->check = csum_tcpudp_magic(fl4->saddr, fl4->daddr, len,
 886				      sk->sk_protocol, csum);
 887	if (uh->check == 0)
 888		uh->check = CSUM_MANGLED_0;
 889
 890send:
 891	err = ip_send_skb(sock_net(sk), skb);
 892	if (err) {
 893		if (err == -ENOBUFS && !inet->recverr) {
 894			UDP_INC_STATS(sock_net(sk),
 895				      UDP_MIB_SNDBUFERRORS, is_udplite);
 896			err = 0;
 897		}
 898	} else
 899		UDP_INC_STATS(sock_net(sk),
 900			      UDP_MIB_OUTDATAGRAMS, is_udplite);
 901	return err;
 902}
 903
 904/*
 905 * Push out all pending data as one UDP datagram. Socket is locked.
 906 */
 907int udp_push_pending_frames(struct sock *sk)
 908{
 909	struct udp_sock  *up = udp_sk(sk);
 910	struct inet_sock *inet = inet_sk(sk);
 911	struct flowi4 *fl4 = &inet->cork.fl.u.ip4;
 912	struct sk_buff *skb;
 913	int err = 0;
 914
 915	skb = ip_finish_skb(sk, fl4);
 916	if (!skb)
 917		goto out;
 918
 919	err = udp_send_skb(skb, fl4, &inet->cork.base);
 920
 921out:
 922	up->len = 0;
 923	up->pending = 0;
 924	return err;
 925}
 926EXPORT_SYMBOL(udp_push_pending_frames);
 927
 928static int __udp_cmsg_send(struct cmsghdr *cmsg, u16 *gso_size)
 929{
 930	switch (cmsg->cmsg_type) {
 931	case UDP_SEGMENT:
 932		if (cmsg->cmsg_len != CMSG_LEN(sizeof(__u16)))
 933			return -EINVAL;
 934		*gso_size = *(__u16 *)CMSG_DATA(cmsg);
 935		return 0;
 936	default:
 937		return -EINVAL;
 938	}
 939}
 940
 941int udp_cmsg_send(struct sock *sk, struct msghdr *msg, u16 *gso_size)
 942{
 943	struct cmsghdr *cmsg;
 944	bool need_ip = false;
 945	int err;
 946
 947	for_each_cmsghdr(cmsg, msg) {
 948		if (!CMSG_OK(msg, cmsg))
 949			return -EINVAL;
 950
 951		if (cmsg->cmsg_level != SOL_UDP) {
 952			need_ip = true;
 953			continue;
 954		}
 955
 956		err = __udp_cmsg_send(cmsg, gso_size);
 957		if (err)
 958			return err;
 959	}
 960
 961	return need_ip;
 962}
 963EXPORT_SYMBOL_GPL(udp_cmsg_send);
 964
 965int udp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
 966{
 967	struct inet_sock *inet = inet_sk(sk);
 968	struct udp_sock *up = udp_sk(sk);
 969	DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
 970	struct flowi4 fl4_stack;
 971	struct flowi4 *fl4;
 972	int ulen = len;
 973	struct ipcm_cookie ipc;
 974	struct rtable *rt = NULL;
 975	int free = 0;
 976	int connected = 0;
 977	__be32 daddr, faddr, saddr;
 978	__be16 dport;
 979	u8  tos;
 980	int err, is_udplite = IS_UDPLITE(sk);
 981	int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
 982	int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
 983	struct sk_buff *skb;
 984	struct ip_options_data opt_copy;
 985
 986	if (len > 0xFFFF)
 987		return -EMSGSIZE;
 988
 989	/*
 990	 *	Check the flags.
 991	 */
 992
 993	if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
 994		return -EOPNOTSUPP;
 995
 996	getfrag = is_udplite ? udplite_getfrag : ip_generic_getfrag;
 997
 998	fl4 = &inet->cork.fl.u.ip4;
 999	if (up->pending) {
1000		/*
1001		 * There are pending frames.
1002		 * The socket lock must be held while it's corked.
1003		 */
1004		lock_sock(sk);
1005		if (likely(up->pending)) {
1006			if (unlikely(up->pending != AF_INET)) {
1007				release_sock(sk);
1008				return -EINVAL;
1009			}
1010			goto do_append_data;
1011		}
1012		release_sock(sk);
1013	}
1014	ulen += sizeof(struct udphdr);
1015
1016	/*
1017	 *	Get and verify the address.
1018	 */
1019	if (usin) {
1020		if (msg->msg_namelen < sizeof(*usin))
1021			return -EINVAL;
1022		if (usin->sin_family != AF_INET) {
1023			if (usin->sin_family != AF_UNSPEC)
1024				return -EAFNOSUPPORT;
1025		}
1026
1027		daddr = usin->sin_addr.s_addr;
1028		dport = usin->sin_port;
1029		if (dport == 0)
1030			return -EINVAL;
1031	} else {
1032		if (sk->sk_state != TCP_ESTABLISHED)
1033			return -EDESTADDRREQ;
1034		daddr = inet->inet_daddr;
1035		dport = inet->inet_dport;
1036		/* Open fast path for connected socket.
1037		   Route will not be used, if at least one option is set.
1038		 */
1039		connected = 1;
1040	}
1041
1042	ipcm_init_sk(&ipc, inet);
1043	ipc.gso_size = up->gso_size;
1044
1045	if (msg->msg_controllen) {
1046		err = udp_cmsg_send(sk, msg, &ipc.gso_size);
1047		if (err > 0)
1048			err = ip_cmsg_send(sk, msg, &ipc,
1049					   sk->sk_family == AF_INET6);
1050		if (unlikely(err < 0)) {
1051			kfree(ipc.opt);
1052			return err;
1053		}
1054		if (ipc.opt)
1055			free = 1;
1056		connected = 0;
1057	}
1058	if (!ipc.opt) {
1059		struct ip_options_rcu *inet_opt;
1060
1061		rcu_read_lock();
1062		inet_opt = rcu_dereference(inet->inet_opt);
1063		if (inet_opt) {
1064			memcpy(&opt_copy, inet_opt,
1065			       sizeof(*inet_opt) + inet_opt->opt.optlen);
1066			ipc.opt = &opt_copy.opt;
1067		}
1068		rcu_read_unlock();
1069	}
1070
1071	if (cgroup_bpf_enabled && !connected) {
1072		err = BPF_CGROUP_RUN_PROG_UDP4_SENDMSG_LOCK(sk,
1073					    (struct sockaddr *)usin, &ipc.addr);
1074		if (err)
1075			goto out_free;
1076		if (usin) {
1077			if (usin->sin_port == 0) {
1078				/* BPF program set invalid port. Reject it. */
1079				err = -EINVAL;
1080				goto out_free;
1081			}
1082			daddr = usin->sin_addr.s_addr;
1083			dport = usin->sin_port;
1084		}
1085	}
1086
1087	saddr = ipc.addr;
1088	ipc.addr = faddr = daddr;
1089
1090	if (ipc.opt && ipc.opt->opt.srr) {
1091		if (!daddr) {
1092			err = -EINVAL;
1093			goto out_free;
1094		}
1095		faddr = ipc.opt->opt.faddr;
1096		connected = 0;
1097	}
1098	tos = get_rttos(&ipc, inet);
1099	if (sock_flag(sk, SOCK_LOCALROUTE) ||
1100	    (msg->msg_flags & MSG_DONTROUTE) ||
1101	    (ipc.opt && ipc.opt->opt.is_strictroute)) {
1102		tos |= RTO_ONLINK;
1103		connected = 0;
1104	}
1105
1106	if (ipv4_is_multicast(daddr)) {
1107		if (!ipc.oif || netif_index_is_l3_master(sock_net(sk), ipc.oif))
1108			ipc.oif = inet->mc_index;
1109		if (!saddr)
1110			saddr = inet->mc_addr;
1111		connected = 0;
1112	} else if (!ipc.oif) {
1113		ipc.oif = inet->uc_index;
1114	} else if (ipv4_is_lbcast(daddr) && inet->uc_index) {
1115		/* oif is set, packet is to local broadcast and
1116		 * and uc_index is set. oif is most likely set
1117		 * by sk_bound_dev_if. If uc_index != oif check if the
1118		 * oif is an L3 master and uc_index is an L3 slave.
1119		 * If so, we want to allow the send using the uc_index.
1120		 */
1121		if (ipc.oif != inet->uc_index &&
1122		    ipc.oif == l3mdev_master_ifindex_by_index(sock_net(sk),
1123							      inet->uc_index)) {
1124			ipc.oif = inet->uc_index;
1125		}
1126	}
1127
1128	if (connected)
1129		rt = (struct rtable *)sk_dst_check(sk, 0);
1130
1131	if (!rt) {
1132		struct net *net = sock_net(sk);
1133		__u8 flow_flags = inet_sk_flowi_flags(sk);
1134
1135		fl4 = &fl4_stack;
1136
1137		flowi4_init_output(fl4, ipc.oif, ipc.sockc.mark, tos,
1138				   RT_SCOPE_UNIVERSE, sk->sk_protocol,
1139				   flow_flags,
1140				   faddr, saddr, dport, inet->inet_sport,
1141				   sk->sk_uid);
1142
1143		security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
1144		rt = ip_route_output_flow(net, fl4, sk);
1145		if (IS_ERR(rt)) {
1146			err = PTR_ERR(rt);
1147			rt = NULL;
1148			if (err == -ENETUNREACH)
1149				IP_INC_STATS(net, IPSTATS_MIB_OUTNOROUTES);
1150			goto out;
1151		}
1152
1153		err = -EACCES;
1154		if ((rt->rt_flags & RTCF_BROADCAST) &&
1155		    !sock_flag(sk, SOCK_BROADCAST))
1156			goto out;
1157		if (connected)
1158			sk_dst_set(sk, dst_clone(&rt->dst));
1159	}
1160
1161	if (msg->msg_flags&MSG_CONFIRM)
1162		goto do_confirm;
1163back_from_confirm:
1164
1165	saddr = fl4->saddr;
1166	if (!ipc.addr)
1167		daddr = ipc.addr = fl4->daddr;
1168
1169	/* Lockless fast path for the non-corking case. */
1170	if (!corkreq) {
1171		struct inet_cork cork;
1172
1173		skb = ip_make_skb(sk, fl4, getfrag, msg, ulen,
1174				  sizeof(struct udphdr), &ipc, &rt,
1175				  &cork, msg->msg_flags);
1176		err = PTR_ERR(skb);
1177		if (!IS_ERR_OR_NULL(skb))
1178			err = udp_send_skb(skb, fl4, &cork);
1179		goto out;
1180	}
1181
1182	lock_sock(sk);
1183	if (unlikely(up->pending)) {
1184		/* The socket is already corked while preparing it. */
1185		/* ... which is an evident application bug. --ANK */
1186		release_sock(sk);
1187
1188		net_dbg_ratelimited("socket already corked\n");
1189		err = -EINVAL;
1190		goto out;
1191	}
1192	/*
1193	 *	Now cork the socket to pend data.
1194	 */
1195	fl4 = &inet->cork.fl.u.ip4;
1196	fl4->daddr = daddr;
1197	fl4->saddr = saddr;
1198	fl4->fl4_dport = dport;
1199	fl4->fl4_sport = inet->inet_sport;
1200	up->pending = AF_INET;
1201
1202do_append_data:
1203	up->len += ulen;
1204	err = ip_append_data(sk, fl4, getfrag, msg, ulen,
1205			     sizeof(struct udphdr), &ipc, &rt,
1206			     corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
1207	if (err)
1208		udp_flush_pending_frames(sk);
1209	else if (!corkreq)
1210		err = udp_push_pending_frames(sk);
1211	else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
1212		up->pending = 0;
1213	release_sock(sk);
1214
1215out:
1216	ip_rt_put(rt);
1217out_free:
1218	if (free)
1219		kfree(ipc.opt);
1220	if (!err)
1221		return len;
1222	/*
1223	 * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
1224	 * ENOBUFS might not be good (it's not tunable per se), but otherwise
1225	 * we don't have a good statistic (IpOutDiscards but it can be too many
1226	 * things).  We could add another new stat but at least for now that
1227	 * seems like overkill.
1228	 */
1229	if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1230		UDP_INC_STATS(sock_net(sk),
1231			      UDP_MIB_SNDBUFERRORS, is_udplite);
1232	}
1233	return err;
1234
1235do_confirm:
1236	if (msg->msg_flags & MSG_PROBE)
1237		dst_confirm_neigh(&rt->dst, &fl4->daddr);
1238	if (!(msg->msg_flags&MSG_PROBE) || len)
1239		goto back_from_confirm;
1240	err = 0;
1241	goto out;
1242}
1243EXPORT_SYMBOL(udp_sendmsg);
1244
1245int udp_sendpage(struct sock *sk, struct page *page, int offset,
1246		 size_t size, int flags)
1247{
1248	struct inet_sock *inet = inet_sk(sk);
1249	struct udp_sock *up = udp_sk(sk);
1250	int ret;
1251
1252	if (flags & MSG_SENDPAGE_NOTLAST)
1253		flags |= MSG_MORE;
1254
1255	if (!up->pending) {
1256		struct msghdr msg = {	.msg_flags = flags|MSG_MORE };
1257
1258		/* Call udp_sendmsg to specify destination address which
1259		 * sendpage interface can't pass.
1260		 * This will succeed only when the socket is connected.
1261		 */
1262		ret = udp_sendmsg(sk, &msg, 0);
1263		if (ret < 0)
1264			return ret;
1265	}
1266
1267	lock_sock(sk);
1268
1269	if (unlikely(!up->pending)) {
1270		release_sock(sk);
1271
1272		net_dbg_ratelimited("cork failed\n");
1273		return -EINVAL;
1274	}
1275
1276	ret = ip_append_page(sk, &inet->cork.fl.u.ip4,
1277			     page, offset, size, flags);
1278	if (ret == -EOPNOTSUPP) {
1279		release_sock(sk);
1280		return sock_no_sendpage(sk->sk_socket, page, offset,
1281					size, flags);
1282	}
1283	if (ret < 0) {
1284		udp_flush_pending_frames(sk);
1285		goto out;
1286	}
1287
1288	up->len += size;
1289	if (!(up->corkflag || (flags&MSG_MORE)))
1290		ret = udp_push_pending_frames(sk);
1291	if (!ret)
1292		ret = size;
1293out:
1294	release_sock(sk);
1295	return ret;
1296}
1297
1298#define UDP_SKB_IS_STATELESS 0x80000000
1299
1300/* all head states (dst, sk, nf conntrack) except skb extensions are
1301 * cleared by udp_rcv().
1302 *
1303 * We need to preserve secpath, if present, to eventually process
1304 * IP_CMSG_PASSSEC at recvmsg() time.
1305 *
1306 * Other extensions can be cleared.
1307 */
1308static bool udp_try_make_stateless(struct sk_buff *skb)
1309{
1310	if (!skb_has_extensions(skb))
1311		return true;
1312
1313	if (!secpath_exists(skb)) {
1314		skb_ext_reset(skb);
1315		return true;
1316	}
1317
1318	return false;
1319}
1320
1321static void udp_set_dev_scratch(struct sk_buff *skb)
1322{
1323	struct udp_dev_scratch *scratch = udp_skb_scratch(skb);
1324
1325	BUILD_BUG_ON(sizeof(struct udp_dev_scratch) > sizeof(long));
1326	scratch->_tsize_state = skb->truesize;
1327#if BITS_PER_LONG == 64
1328	scratch->len = skb->len;
1329	scratch->csum_unnecessary = !!skb_csum_unnecessary(skb);
1330	scratch->is_linear = !skb_is_nonlinear(skb);
1331#endif
1332	if (udp_try_make_stateless(skb))
1333		scratch->_tsize_state |= UDP_SKB_IS_STATELESS;
1334}
1335
1336static void udp_skb_csum_unnecessary_set(struct sk_buff *skb)
1337{
1338	/* We come here after udp_lib_checksum_complete() returned 0.
1339	 * This means that __skb_checksum_complete() might have
1340	 * set skb->csum_valid to 1.
1341	 * On 64bit platforms, we can set csum_unnecessary
1342	 * to true, but only if the skb is not shared.
1343	 */
1344#if BITS_PER_LONG == 64
1345	if (!skb_shared(skb))
1346		udp_skb_scratch(skb)->csum_unnecessary = true;
1347#endif
1348}
1349
1350static int udp_skb_truesize(struct sk_buff *skb)
1351{
1352	return udp_skb_scratch(skb)->_tsize_state & ~UDP_SKB_IS_STATELESS;
1353}
1354
1355static bool udp_skb_has_head_state(struct sk_buff *skb)
1356{
1357	return !(udp_skb_scratch(skb)->_tsize_state & UDP_SKB_IS_STATELESS);
1358}
1359
1360/* fully reclaim rmem/fwd memory allocated for skb */
1361static void udp_rmem_release(struct sock *sk, int size, int partial,
1362			     bool rx_queue_lock_held)
1363{
1364	struct udp_sock *up = udp_sk(sk);
1365	struct sk_buff_head *sk_queue;
1366	int amt;
1367
1368	if (likely(partial)) {
1369		up->forward_deficit += size;
1370		size = up->forward_deficit;
1371		if (size < (sk->sk_rcvbuf >> 2) &&
1372		    !skb_queue_empty(&up->reader_queue))
1373			return;
1374	} else {
1375		size += up->forward_deficit;
1376	}
1377	up->forward_deficit = 0;
1378
1379	/* acquire the sk_receive_queue for fwd allocated memory scheduling,
1380	 * if the called don't held it already
1381	 */
1382	sk_queue = &sk->sk_receive_queue;
1383	if (!rx_queue_lock_held)
1384		spin_lock(&sk_queue->lock);
1385
1386
1387	sk->sk_forward_alloc += size;
1388	amt = (sk->sk_forward_alloc - partial) & ~(SK_MEM_QUANTUM - 1);
1389	sk->sk_forward_alloc -= amt;
1390
1391	if (amt)
1392		__sk_mem_reduce_allocated(sk, amt >> SK_MEM_QUANTUM_SHIFT);
1393
1394	atomic_sub(size, &sk->sk_rmem_alloc);
1395
1396	/* this can save us from acquiring the rx queue lock on next receive */
1397	skb_queue_splice_tail_init(sk_queue, &up->reader_queue);
1398
1399	if (!rx_queue_lock_held)
1400		spin_unlock(&sk_queue->lock);
1401}
1402
1403/* Note: called with reader_queue.lock held.
1404 * Instead of using skb->truesize here, find a copy of it in skb->dev_scratch
1405 * This avoids a cache line miss while receive_queue lock is held.
1406 * Look at __udp_enqueue_schedule_skb() to find where this copy is done.
1407 */
1408void udp_skb_destructor(struct sock *sk, struct sk_buff *skb)
1409{
1410	prefetch(&skb->data);
1411	udp_rmem_release(sk, udp_skb_truesize(skb), 1, false);
1412}
1413EXPORT_SYMBOL(udp_skb_destructor);
1414
1415/* as above, but the caller held the rx queue lock, too */
1416static void udp_skb_dtor_locked(struct sock *sk, struct sk_buff *skb)
1417{
1418	prefetch(&skb->data);
1419	udp_rmem_release(sk, udp_skb_truesize(skb), 1, true);
1420}
1421
1422/* Idea of busylocks is to let producers grab an extra spinlock
1423 * to relieve pressure on the receive_queue spinlock shared by consumer.
1424 * Under flood, this means that only one producer can be in line
1425 * trying to acquire the receive_queue spinlock.
1426 * These busylock can be allocated on a per cpu manner, instead of a
1427 * per socket one (that would consume a cache line per socket)
1428 */
1429static int udp_busylocks_log __read_mostly;
1430static spinlock_t *udp_busylocks __read_mostly;
1431
1432static spinlock_t *busylock_acquire(void *ptr)
1433{
1434	spinlock_t *busy;
1435
1436	busy = udp_busylocks + hash_ptr(ptr, udp_busylocks_log);
1437	spin_lock(busy);
1438	return busy;
1439}
1440
1441static void busylock_release(spinlock_t *busy)
1442{
1443	if (busy)
1444		spin_unlock(busy);
1445}
1446
1447int __udp_enqueue_schedule_skb(struct sock *sk, struct sk_buff *skb)
1448{
1449	struct sk_buff_head *list = &sk->sk_receive_queue;
1450	int rmem, delta, amt, err = -ENOMEM;
1451	spinlock_t *busy = NULL;
1452	int size;
1453
1454	/* try to avoid the costly atomic add/sub pair when the receive
1455	 * queue is full; always allow at least a packet
1456	 */
1457	rmem = atomic_read(&sk->sk_rmem_alloc);
1458	if (rmem > sk->sk_rcvbuf)
1459		goto drop;
1460
1461	/* Under mem pressure, it might be helpful to help udp_recvmsg()
1462	 * having linear skbs :
1463	 * - Reduce memory overhead and thus increase receive queue capacity
1464	 * - Less cache line misses at copyout() time
1465	 * - Less work at consume_skb() (less alien page frag freeing)
1466	 */
1467	if (rmem > (sk->sk_rcvbuf >> 1)) {
1468		skb_condense(skb);
1469
1470		busy = busylock_acquire(sk);
1471	}
1472	size = skb->truesize;
1473	udp_set_dev_scratch(skb);
1474
1475	/* we drop only if the receive buf is full and the receive
1476	 * queue contains some other skb
1477	 */
1478	rmem = atomic_add_return(size, &sk->sk_rmem_alloc);
1479	if (rmem > (size + (unsigned int)sk->sk_rcvbuf))
1480		goto uncharge_drop;
1481
1482	spin_lock(&list->lock);
1483	if (size >= sk->sk_forward_alloc) {
1484		amt = sk_mem_pages(size);
1485		delta = amt << SK_MEM_QUANTUM_SHIFT;
1486		if (!__sk_mem_raise_allocated(sk, delta, amt, SK_MEM_RECV)) {
1487			err = -ENOBUFS;
1488			spin_unlock(&list->lock);
1489			goto uncharge_drop;
1490		}
1491
1492		sk->sk_forward_alloc += delta;
1493	}
1494
1495	sk->sk_forward_alloc -= size;
1496
1497	/* no need to setup a destructor, we will explicitly release the
1498	 * forward allocated memory on dequeue
1499	 */
1500	sock_skb_set_dropcount(sk, skb);
1501
1502	__skb_queue_tail(list, skb);
1503	spin_unlock(&list->lock);
1504
1505	if (!sock_flag(sk, SOCK_DEAD))
1506		sk->sk_data_ready(sk);
1507
1508	busylock_release(busy);
1509	return 0;
1510
1511uncharge_drop:
1512	atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1513
1514drop:
1515	atomic_inc(&sk->sk_drops);
1516	busylock_release(busy);
1517	return err;
1518}
1519EXPORT_SYMBOL_GPL(__udp_enqueue_schedule_skb);
1520
1521void udp_destruct_sock(struct sock *sk)
1522{
1523	/* reclaim completely the forward allocated memory */
1524	struct udp_sock *up = udp_sk(sk);
1525	unsigned int total = 0;
1526	struct sk_buff *skb;
1527
1528	skb_queue_splice_tail_init(&sk->sk_receive_queue, &up->reader_queue);
1529	while ((skb = __skb_dequeue(&up->reader_queue)) != NULL) {
1530		total += skb->truesize;
1531		kfree_skb(skb);
1532	}
1533	udp_rmem_release(sk, total, 0, true);
1534
1535	inet_sock_destruct(sk);
1536}
1537EXPORT_SYMBOL_GPL(udp_destruct_sock);
1538
1539int udp_init_sock(struct sock *sk)
1540{
1541	skb_queue_head_init(&udp_sk(sk)->reader_queue);
1542	sk->sk_destruct = udp_destruct_sock;
1543	return 0;
1544}
1545EXPORT_SYMBOL_GPL(udp_init_sock);
1546
1547void skb_consume_udp(struct sock *sk, struct sk_buff *skb, int len)
1548{
1549	if (unlikely(READ_ONCE(sk->sk_peek_off) >= 0)) {
1550		bool slow = lock_sock_fast(sk);
1551
1552		sk_peek_offset_bwd(sk, len);
1553		unlock_sock_fast(sk, slow);
1554	}
1555
1556	if (!skb_unref(skb))
1557		return;
1558
1559	/* In the more common cases we cleared the head states previously,
1560	 * see __udp_queue_rcv_skb().
1561	 */
1562	if (unlikely(udp_skb_has_head_state(skb)))
1563		skb_release_head_state(skb);
1564	__consume_stateless_skb(skb);
1565}
1566EXPORT_SYMBOL_GPL(skb_consume_udp);
1567
1568static struct sk_buff *__first_packet_length(struct sock *sk,
1569					     struct sk_buff_head *rcvq,
1570					     int *total)
1571{
1572	struct sk_buff *skb;
1573
1574	while ((skb = skb_peek(rcvq)) != NULL) {
1575		if (udp_lib_checksum_complete(skb)) {
1576			__UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS,
1577					IS_UDPLITE(sk));
1578			__UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS,
1579					IS_UDPLITE(sk));
1580			atomic_inc(&sk->sk_drops);
1581			__skb_unlink(skb, rcvq);
1582			*total += skb->truesize;
1583			kfree_skb(skb);
1584		} else {
1585			udp_skb_csum_unnecessary_set(skb);
1586			break;
1587		}
1588	}
1589	return skb;
1590}
1591
1592/**
1593 *	first_packet_length	- return length of first packet in receive queue
1594 *	@sk: socket
1595 *
1596 *	Drops all bad checksum frames, until a valid one is found.
1597 *	Returns the length of found skb, or -1 if none is found.
1598 */
1599static int first_packet_length(struct sock *sk)
1600{
1601	struct sk_buff_head *rcvq = &udp_sk(sk)->reader_queue;
1602	struct sk_buff_head *sk_queue = &sk->sk_receive_queue;
1603	struct sk_buff *skb;
1604	int total = 0;
1605	int res;
1606
1607	spin_lock_bh(&rcvq->lock);
1608	skb = __first_packet_length(sk, rcvq, &total);
1609	if (!skb && !skb_queue_empty_lockless(sk_queue)) {
1610		spin_lock(&sk_queue->lock);
1611		skb_queue_splice_tail_init(sk_queue, rcvq);
1612		spin_unlock(&sk_queue->lock);
1613
1614		skb = __first_packet_length(sk, rcvq, &total);
1615	}
1616	res = skb ? skb->len : -1;
1617	if (total)
1618		udp_rmem_release(sk, total, 1, false);
1619	spin_unlock_bh(&rcvq->lock);
1620	return res;
1621}
1622
1623/*
1624 *	IOCTL requests applicable to the UDP protocol
1625 */
1626
1627int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
1628{
1629	switch (cmd) {
1630	case SIOCOUTQ:
1631	{
1632		int amount = sk_wmem_alloc_get(sk);
1633
1634		return put_user(amount, (int __user *)arg);
1635	}
1636
1637	case SIOCINQ:
1638	{
1639		int amount = max_t(int, 0, first_packet_length(sk));
1640
1641		return put_user(amount, (int __user *)arg);
1642	}
1643
1644	default:
1645		return -ENOIOCTLCMD;
1646	}
1647
1648	return 0;
1649}
1650EXPORT_SYMBOL(udp_ioctl);
1651
1652struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags,
1653			       int noblock, int *off, int *err)
1654{
1655	struct sk_buff_head *sk_queue = &sk->sk_receive_queue;
1656	struct sk_buff_head *queue;
1657	struct sk_buff *last;
1658	long timeo;
1659	int error;
1660
1661	queue = &udp_sk(sk)->reader_queue;
1662	flags |= noblock ? MSG_DONTWAIT : 0;
1663	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1664	do {
1665		struct sk_buff *skb;
1666
1667		error = sock_error(sk);
1668		if (error)
1669			break;
1670
1671		error = -EAGAIN;
1672		do {
1673			spin_lock_bh(&queue->lock);
1674			skb = __skb_try_recv_from_queue(sk, queue, flags, off,
1675							err, &last);
1676			if (skb) {
1677				if (!(flags & MSG_PEEK))
1678					udp_skb_destructor(sk, skb);
1679				spin_unlock_bh(&queue->lock);
1680				return skb;
1681			}
1682
1683			if (skb_queue_empty_lockless(sk_queue)) {
1684				spin_unlock_bh(&queue->lock);
1685				goto busy_check;
1686			}
1687
1688			/* refill the reader queue and walk it again
1689			 * keep both queues locked to avoid re-acquiring
1690			 * the sk_receive_queue lock if fwd memory scheduling
1691			 * is needed.
1692			 */
1693			spin_lock(&sk_queue->lock);
1694			skb_queue_splice_tail_init(sk_queue, queue);
1695
1696			skb = __skb_try_recv_from_queue(sk, queue, flags, off,
1697							err, &last);
1698			if (skb && !(flags & MSG_PEEK))
1699				udp_skb_dtor_locked(sk, skb);
1700			spin_unlock(&sk_queue->lock);
1701			spin_unlock_bh(&queue->lock);
1702			if (skb)
1703				return skb;
1704
1705busy_check:
1706			if (!sk_can_busy_loop(sk))
1707				break;
1708
1709			sk_busy_loop(sk, flags & MSG_DONTWAIT);
1710		} while (!skb_queue_empty_lockless(sk_queue));
1711
1712		/* sk_queue is empty, reader_queue may contain peeked packets */
1713	} while (timeo &&
1714		 !__skb_wait_for_more_packets(sk, &sk->sk_receive_queue,
1715					      &error, &timeo,
1716					      (struct sk_buff *)sk_queue));
1717
1718	*err = error;
1719	return NULL;
1720}
1721EXPORT_SYMBOL(__skb_recv_udp);
1722
1723/*
1724 * 	This should be easy, if there is something there we
1725 * 	return it, otherwise we block.
1726 */
1727
1728int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock,
1729		int flags, int *addr_len)
1730{
1731	struct inet_sock *inet = inet_sk(sk);
1732	DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
1733	struct sk_buff *skb;
1734	unsigned int ulen, copied;
1735	int off, err, peeking = flags & MSG_PEEK;
1736	int is_udplite = IS_UDPLITE(sk);
1737	bool checksum_valid = false;
1738
1739	if (flags & MSG_ERRQUEUE)
1740		return ip_recv_error(sk, msg, len, addr_len);
1741
1742try_again:
1743	off = sk_peek_offset(sk, flags);
1744	skb = __skb_recv_udp(sk, flags, noblock, &off, &err);
1745	if (!skb)
1746		return err;
1747
1748	ulen = udp_skb_len(skb);
1749	copied = len;
1750	if (copied > ulen - off)
1751		copied = ulen - off;
1752	else if (copied < ulen)
1753		msg->msg_flags |= MSG_TRUNC;
1754
1755	/*
1756	 * If checksum is needed at all, try to do it while copying the
1757	 * data.  If the data is truncated, or if we only want a partial
1758	 * coverage checksum (UDP-Lite), do it before the copy.
1759	 */
1760
1761	if (copied < ulen || peeking ||
1762	    (is_udplite && UDP_SKB_CB(skb)->partial_cov)) {
1763		checksum_valid = udp_skb_csum_unnecessary(skb) ||
1764				!__udp_lib_checksum_complete(skb);
1765		if (!checksum_valid)
1766			goto csum_copy_err;
1767	}
1768
1769	if (checksum_valid || udp_skb_csum_unnecessary(skb)) {
1770		if (udp_skb_is_linear(skb))
1771			err = copy_linear_skb(skb, copied, off, &msg->msg_iter);
1772		else
1773			err = skb_copy_datagram_msg(skb, off, msg, copied);
1774	} else {
1775		err = skb_copy_and_csum_datagram_msg(skb, off, msg);
1776
1777		if (err == -EINVAL)
1778			goto csum_copy_err;
1779	}
1780
1781	if (unlikely(err)) {
1782		if (!peeking) {
1783			atomic_inc(&sk->sk_drops);
1784			UDP_INC_STATS(sock_net(sk),
1785				      UDP_MIB_INERRORS, is_udplite);
1786		}
1787		kfree_skb(skb);
1788		return err;
1789	}
1790
1791	if (!peeking)
1792		UDP_INC_STATS(sock_net(sk),
1793			      UDP_MIB_INDATAGRAMS, is_udplite);
1794
1795	sock_recv_ts_and_drops(msg, sk, skb);
1796
1797	/* Copy the address. */
1798	if (sin) {
1799		sin->sin_family = AF_INET;
1800		sin->sin_port = udp_hdr(skb)->source;
1801		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
1802		memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
1803		*addr_len = sizeof(*sin);
1804
1805		if (cgroup_bpf_enabled)
1806			BPF_CGROUP_RUN_PROG_UDP4_RECVMSG_LOCK(sk,
1807							(struct sockaddr *)sin);
1808	}
1809
1810	if (udp_sk(sk)->gro_enabled)
1811		udp_cmsg_recv(msg, sk, skb);
1812
1813	if (inet->cmsg_flags)
1814		ip_cmsg_recv_offset(msg, sk, skb, sizeof(struct udphdr), off);
1815
1816	err = copied;
1817	if (flags & MSG_TRUNC)
1818		err = ulen;
1819
1820	skb_consume_udp(sk, skb, peeking ? -err : err);
1821	return err;
1822
1823csum_copy_err:
1824	if (!__sk_queue_drop_skb(sk, &udp_sk(sk)->reader_queue, skb, flags,
1825				 udp_skb_destructor)) {
1826		UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
1827		UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
1828	}
1829	kfree_skb(skb);
1830
1831	/* starting over for a new packet, but check if we need to yield */
1832	cond_resched();
1833	msg->msg_flags &= ~MSG_TRUNC;
1834	goto try_again;
1835}
1836
1837int udp_pre_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
1838{
1839	/* This check is replicated from __ip4_datagram_connect() and
1840	 * intended to prevent BPF program called below from accessing bytes
1841	 * that are out of the bound specified by user in addr_len.
1842	 */
1843	if (addr_len < sizeof(struct sockaddr_in))
1844		return -EINVAL;
1845
1846	return BPF_CGROUP_RUN_PROG_INET4_CONNECT_LOCK(sk, uaddr);
1847}
1848EXPORT_SYMBOL(udp_pre_connect);
1849
1850int __udp_disconnect(struct sock *sk, int flags)
1851{
1852	struct inet_sock *inet = inet_sk(sk);
1853	/*
1854	 *	1003.1g - break association.
1855	 */
1856
1857	sk->sk_state = TCP_CLOSE;
1858	inet->inet_daddr = 0;
1859	inet->inet_dport = 0;
1860	sock_rps_reset_rxhash(sk);
1861	sk->sk_bound_dev_if = 0;
1862	if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) {
1863		inet_reset_saddr(sk);
1864		if (sk->sk_prot->rehash &&
1865		    (sk->sk_userlocks & SOCK_BINDPORT_LOCK))
1866			sk->sk_prot->rehash(sk);
1867	}
1868
1869	if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
1870		sk->sk_prot->unhash(sk);
1871		inet->inet_sport = 0;
1872	}
1873	sk_dst_reset(sk);
1874	return 0;
1875}
1876EXPORT_SYMBOL(__udp_disconnect);
1877
1878int udp_disconnect(struct sock *sk, int flags)
1879{
1880	lock_sock(sk);
1881	__udp_disconnect(sk, flags);
1882	release_sock(sk);
1883	return 0;
1884}
1885EXPORT_SYMBOL(udp_disconnect);
1886
1887void udp_lib_unhash(struct sock *sk)
1888{
1889	if (sk_hashed(sk)) {
1890		struct udp_table *udptable = sk->sk_prot->h.udp_table;
1891		struct udp_hslot *hslot, *hslot2;
1892
1893		hslot  = udp_hashslot(udptable, sock_net(sk),
1894				      udp_sk(sk)->udp_port_hash);
1895		hslot2 = udp_hashslot2(udptable, udp_sk(sk)->udp_portaddr_hash);
1896
1897		spin_lock_bh(&hslot->lock);
1898		if (rcu_access_pointer(sk->sk_reuseport_cb))
1899			reuseport_detach_sock(sk);
1900		if (sk_del_node_init_rcu(sk)) {
1901			hslot->count--;
1902			inet_sk(sk)->inet_num = 0;
1903			sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
1904
1905			spin_lock(&hslot2->lock);
1906			hlist_del_init_rcu(&udp_sk(sk)->udp_portaddr_node);
1907			hslot2->count--;
1908			spin_unlock(&hslot2->lock);
1909		}
1910		spin_unlock_bh(&hslot->lock);
1911	}
1912}
1913EXPORT_SYMBOL(udp_lib_unhash);
1914
1915/*
1916 * inet_rcv_sa…

Large files files are truncated, but you can click here to view the full file