forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87 
 kernel/net/ipv4/inet_connection_sock.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * INET		An implementation of the TCP/IP protocol suite for the LINUX
34  *		operating system.  INET is implemented using the  BSD Socket
....@@ -6,11 +7,6 @@
67  *		Support for INET connection oriented protocols.
78  *
89  * Authors:	See the TCP sources
9
- *
10
- *		This program is free software; you can redistribute it and/or
11
- *		modify it under the terms of the GNU General Public License
12
- *		as published by the Free Software Foundation; either version
13
- *		2 of the License, or(at your option) any later version.
1410  */
1511 
1612 #include <linux/module.h>
....@@ -140,7 +136,7 @@
140136 {
141137 	struct sock *sk2;
142138 	bool reuse = sk->sk_reuse;
143
-	bool reuseport = !!sk->sk_reuseport && reuseport_ok;
139
+	bool reuseport = !!sk->sk_reuseport;
144140 	kuid_t uid = sock_i_uid((struct sock *)sk);
145141 
146142 	/*
....@@ -155,17 +151,21 @@
155151 		    (!sk->sk_bound_dev_if ||
156152 		     !sk2->sk_bound_dev_if ||
157153 		     sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
158
-			if ((!reuse || !sk2->sk_reuse ||
159
-			    sk2->sk_state == TCP_LISTEN) &&
160
-			    (!reuseport || !sk2->sk_reuseport ||
161
-			     rcu_access_pointer(sk->sk_reuseport_cb) ||
162
-			     (sk2->sk_state != TCP_TIME_WAIT &&
163
-			     !uid_eq(uid, sock_i_uid(sk2))))) {
164
-				if (inet_rcv_saddr_equal(sk, sk2, true))
165
-					break;
166
-			}
167
-			if (!relax && reuse && sk2->sk_reuse &&
154
+			if (reuse && sk2->sk_reuse &&
168155 			    sk2->sk_state != TCP_LISTEN) {
156
+				if ((!relax ||
157
+				     (!reuseport_ok &&
158
+				      reuseport && sk2->sk_reuseport &&
159
+				      !rcu_access_pointer(sk->sk_reuseport_cb) &&
160
+				      (sk2->sk_state == TCP_TIME_WAIT ||
161
+				       uid_eq(uid, sock_i_uid(sk2))))) &&
162
+				    inet_rcv_saddr_equal(sk, sk2, true))
163
+					break;
164
+			} else if (!reuseport_ok ||
165
+				   !reuseport || !sk2->sk_reuseport ||
166
+				   rcu_access_pointer(sk->sk_reuseport_cb) ||
167
+				   (sk2->sk_state != TCP_TIME_WAIT &&
168
+				    !uid_eq(uid, sock_i_uid(sk2)))) {
169169 				if (inet_rcv_saddr_equal(sk, sk2, true))
170170 					break;
171171 			}
....@@ -185,10 +185,14 @@
185185 	int port = 0;
186186 	struct inet_bind_hashbucket *head;
187187 	struct net *net = sock_net(sk);
188
+	bool relax = false;
188189 	int i, low, high, attempt_half;
189190 	struct inet_bind_bucket *tb;
190191 	u32 remaining, offset;
192
+	int l3mdev;
191193 
194
+	l3mdev = inet_sk_bound_l3mdev(sk);
195
+ports_exhausted:
192196 	attempt_half = (sk->sk_reuse == SK_CAN_REUSE) ? 1 : 0;
193197 other_half_scan:
194198 	inet_get_local_port_range(net, &low, &high);
....@@ -224,8 +228,9 @@
224228 						  hinfo->bhash_size)];
225229 		spin_lock_bh(&head->lock);
226230 		inet_bind_bucket_for_each(tb, &head->chain)
227
-			if (net_eq(ib_net(tb), net) && tb->port == port) {
228
-				if (!inet_csk_bind_conflict(sk, tb, false, false))
231
+			if (net_eq(ib_net(tb), net) && tb->l3mdev == l3mdev &&
232
+			    tb->port == port) {
233
+				if (!inet_csk_bind_conflict(sk, tb, relax, false))
229234 					goto success;
230235 				goto next_port;
231236 			}
....@@ -244,6 +249,12 @@
244249 		/* OK we now try the upper half of the range */
245250 		attempt_half = 2;
246251 		goto other_half_scan;
252
+	}
253
+
254
+	if (READ_ONCE(net->ipv4.sysctl_ip_autobind_reuse) && !relax) {
255
+		/* We still have a chance to connect to different destinations */
256
+		relax = true;
257
+		goto ports_exhausted;
247258 	}
248259 	return NULL;
249260 success:
....@@ -348,6 +359,9 @@
348359 	struct inet_bind_hashbucket *head;
349360 	struct net *net = sock_net(sk);
350361 	struct inet_bind_bucket *tb = NULL;
362
+	int l3mdev;
363
+
364
+	l3mdev = inet_sk_bound_l3mdev(sk);
351365 
352366 	if (!port) {
353367 		head = inet_csk_find_open_port(sk, &tb, &port);
....@@ -361,11 +375,12 @@
361375 					  hinfo->bhash_size)];
362376 	spin_lock_bh(&head->lock);
363377 	inet_bind_bucket_for_each(tb, &head->chain)
364
-		if (net_eq(ib_net(tb), net) && tb->port == port)
378
+		if (net_eq(ib_net(tb), net) && tb->l3mdev == l3mdev &&
379
+		    tb->port == port)
365380 			goto tb_found;
366381 tb_not_found:
367382 	tb = inet_bind_bucket_create(hinfo->bind_bucket_cachep,
368
-				     net, head, port);
383
+				     net, head, port, l3mdev);
369384 	if (!tb)
370385 		goto fail_unlock;
371386 tb_found:
....@@ -549,7 +564,7 @@
549564 {
550565 	struct inet_connection_sock *icsk = inet_csk(sk);
551566 
552
-	icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
567
+	icsk->icsk_pending = icsk->icsk_ack.pending = 0;
553568 
554569 	sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
555570 	sk_stop_timer(sk, &icsk->icsk_delack_timer);
....@@ -587,7 +602,7 @@
587602 			   (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
588603 			   ireq->ir_loc_addr, ireq->ir_rmt_port,
589604 			   htons(ireq->ir_num), sk->sk_uid);
590
-	security_req_classify_flow(req, flowi4_to_flowi(fl4));
605
+	security_req_classify_flow(req, flowi4_to_flowi_common(fl4));
591606 	rt = ip_route_output_flow(net, fl4, sk);
592607 	if (IS_ERR(rt))
593608 		goto no_route;
....@@ -625,7 +640,7 @@
625640 			   (opt && opt->opt.srr) ? opt->opt.faddr : ireq->ir_rmt_addr,
626641 			   ireq->ir_loc_addr, ireq->ir_rmt_port,
627642 			   htons(ireq->ir_num), sk->sk_uid);
628
-	security_req_classify_flow(req, flowi4_to_flowi(fl4));
643
+	security_req_classify_flow(req, flowi4_to_flowi_common(fl4));
629644 	rt = ip_route_output_flow(net, fl4, sk);
630645 	if (IS_ERR(rt))
631646 		goto no_route;
....@@ -641,27 +656,20 @@
641656 }
642657 EXPORT_SYMBOL_GPL(inet_csk_route_child_sock);
643658 
644
-#if IS_ENABLED(CONFIG_IPV6)
645
-#define AF_INET_FAMILY(fam) ((fam) == AF_INET)
646
-#else
647
-#define AF_INET_FAMILY(fam) true
648
-#endif
649
-
650659 /* Decide when to expire the request and when to resend SYN-ACK */
651
-static inline void syn_ack_recalc(struct request_sock *req, const int thresh,
652
-				  const int max_retries,
653
-				  const u8 rskq_defer_accept,
654
-				  int *expire, int *resend)
660
+static void syn_ack_recalc(struct request_sock *req,
661
+			   const int max_syn_ack_retries,
662
+			   const u8 rskq_defer_accept,
663
+			   int *expire, int *resend)
655664 {
656665 	if (!rskq_defer_accept) {
657
-		*expire = req->num_timeout >= thresh;
666
+		*expire = req->num_timeout >= max_syn_ack_retries;
658667 		*resend = 1;
659668 		return;
660669 	}
661
-	*expire = req->num_timeout >= thresh &&
662
-		  (!inet_rsk(req)->acked || req->num_timeout >= max_retries);
663
-	/*
664
-	 * Do not resend while waiting for data after ACK,
670
+	*expire = req->num_timeout >= max_syn_ack_retries &&
671
+		  (!inet_rsk(req)->acked || req->num_timeout >= rskq_defer_accept);
672
+	/* Do not resend while waiting for data after ACK,
665673 	 * start to resend on end of deferring period to give
666674 	 * last chance for data or ACK to create established socket.
667675 	 */
....@@ -680,8 +688,7 @@
680688 EXPORT_SYMBOL(inet_rtx_syn_ack);
681689 
682690 /* return true if req was found in the ehash table */
683
-static bool reqsk_queue_unlink(struct request_sock_queue *queue,
684
-			       struct request_sock *req)
691
+static bool reqsk_queue_unlink(struct request_sock *req)
685692 {
686693 	struct inet_hashinfo *hashinfo = req_to_sk(req)->sk_prot->h.hashinfo;
687694 	bool found = false;
....@@ -700,7 +707,7 @@
700707 
701708 bool inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req)
702709 {
703
-	bool unlinked = reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req);
710
+	bool unlinked = reqsk_queue_unlink(req);
704711 
705712 	if (unlinked) {
706713 		reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);
....@@ -724,15 +731,12 @@
724731 	struct net *net = sock_net(sk_listener);
725732 	struct inet_connection_sock *icsk = inet_csk(sk_listener);
726733 	struct request_sock_queue *queue = &icsk->icsk_accept_queue;
727
-	int qlen, expire = 0, resend = 0;
728
-	int max_retries, thresh;
729
-	u8 defer_accept;
734
+	int max_syn_ack_retries, qlen, expire = 0, resend = 0;
730735 
731736 	if (inet_sk_state_load(sk_listener) != TCP_LISTEN)
732737 		goto drop;
733738 
734
-	max_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries;
735
-	thresh = max_retries;
739
+	max_syn_ack_retries = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_synack_retries;
736740 	/* Normally all the openreqs are young and become mature
737741 	 * (i.e. converted to established socket) for first timeout.
738742 	 * If synack was not acknowledged for 1 second, it means
....@@ -751,20 +755,17 @@
751755 	 * ones are about to clog our table.
752756 	 */
753757 	qlen = reqsk_queue_len(queue);
754
-	if ((qlen << 1) > max(8U, sk_listener->sk_max_ack_backlog)) {
758
+	if ((qlen << 1) > max(8U, READ_ONCE(sk_listener->sk_max_ack_backlog))) {
755759 		int young = reqsk_queue_len_young(queue) << 1;
756760 
757
-		while (thresh > 2) {
761
+		while (max_syn_ack_retries > 2) {
758762 			if (qlen < young)
759763 				break;
760
-			thresh--;
764
+			max_syn_ack_retries--;
761765 			young <<= 1;
762766 		}
763767 	}
764
-	defer_accept = READ_ONCE(queue->rskq_defer_accept);
765
-	if (defer_accept)
766
-		max_retries = defer_accept;
767
-	syn_ack_recalc(req, thresh, max_retries, defer_accept,
768
+	syn_ack_recalc(req, max_syn_ack_retries, READ_ONCE(queue->rskq_defer_accept),
768769 		       &expire, &resend);
769770 	req->rsk_ops->syn_ack_timeout(req);
770771 	if (!expire &&
....@@ -786,14 +787,10 @@
786787 static void reqsk_queue_hash_req(struct request_sock *req,
787788 				 unsigned long timeout)
788789 {
789
-	req->num_retrans = 0;
790
-	req->num_timeout = 0;
791
-	req->sk = NULL;
792
-
793790 	timer_setup(&req->rsk_timer, reqsk_timer_handler, TIMER_PINNED);
794791 	mod_timer(&req->rsk_timer, jiffies + timeout);
795792 
796
-	inet_ehash_insert(req_to_sk(req), NULL);
793
+	inet_ehash_insert(req_to_sk(req), NULL, NULL);
797794 	/* before letting lookups find us, make sure all req fields
798795 	 * are committed to memory and refcnt initialized.
799796 	 */
....@@ -808,6 +805,18 @@
808805 	inet_csk_reqsk_queue_added(sk);
809806 }
810807 EXPORT_SYMBOL_GPL(inet_csk_reqsk_queue_hash_add);
808
+
809
+static void inet_clone_ulp(const struct request_sock *req, struct sock *newsk,
810
+			   const gfp_t priority)
811
+{
812
+	struct inet_connection_sock *icsk = inet_csk(newsk);
813
+
814
+	if (!icsk->icsk_ulp_ops)
815
+		return;
816
+
817
+	if (icsk->icsk_ulp_ops->clone)
818
+		icsk->icsk_ulp_ops->clone(req, newsk, priority);
819
+}
811820 
812821 /**
813822  *	inet_csk_clone_lock - clone an inet socket, and lock its clone
....@@ -845,9 +854,12 @@
845854 		newicsk->icsk_retransmits = 0;
846855 		newicsk->icsk_backoff	  = 0;
847856 		newicsk->icsk_probes_out  = 0;
857
+		newicsk->icsk_probes_tstamp = 0;
848858 
849859 		/* Deinitialize accept_queue to trap illegal accesses. */
850860 		memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));
861
+
862
+		inet_clone_ulp(req, newsk, priority);
851863 
852864 		security_inet_csk_clone(newsk, req);
853865 	}
....@@ -895,10 +907,7 @@
895907 	/* sk_clone_lock locked the socket and set refcnt to 2 */
896908 	bh_unlock_sock(sk);
897909 	sock_put(sk);
898
-
899
-	/* The below has to be done to allow calling inet_csk_destroy_sock */
900
-	sock_set_flag(sk, SOCK_DEAD);
901
-	percpu_counter_inc(sk->sk_prot->orphan_count);
910
+	inet_csk_prepare_for_destroy_sock(sk);
902911 	inet_sk(sk)->inet_num = 0;
903912 }
904913 EXPORT_SYMBOL(inet_csk_prepare_forced_close);
....@@ -911,7 +920,6 @@
911920 
912921 	reqsk_queue_alloc(&icsk->icsk_accept_queue);
913922 
914
-	sk->sk_max_ack_backlog = backlog;
915923 	sk->sk_ack_backlog = 0;
916924 	inet_csk_delack_init(sk);
917925 
....@@ -946,7 +954,7 @@
946954 	percpu_counter_inc(sk->sk_prot->orphan_count);
947955 
948956 	if (sk->sk_protocol == IPPROTO_TCP && tcp_rsk(req)->tfo_listener) {
949
-		BUG_ON(tcp_sk(child)->fastopen_rsk != req);
957
+		BUG_ON(rcu_access_pointer(tcp_sk(child)->fastopen_rsk) != req);
950958 		BUG_ON(sk != req->rsk_listener);
951959 
952960 		/* Paranoid, to prevent race condition if
....@@ -955,7 +963,7 @@
955963 		 * Also to satisfy an assertion in
956964 		 * tcp_v4_destroy_sock().
957965 		 */
958
-		tcp_sk(child)->fastopen_rsk = NULL;
966
+		RCU_INIT_POINTER(tcp_sk(child)->fastopen_rsk, NULL);
959967 	}
960968 	inet_csk_destroy_sock(child);
961969 }
....@@ -1061,34 +1069,6 @@
10611069 	sin->sin_port		= inet->inet_dport;
10621070 }
10631071 EXPORT_SYMBOL_GPL(inet_csk_addr2sockaddr);
1064
-
1065
-#ifdef CONFIG_COMPAT
1066
-int inet_csk_compat_getsockopt(struct sock *sk, int level, int optname,
1067
-			       char __user *optval, int __user *optlen)
1068
-{
1069
-	const struct inet_connection_sock *icsk = inet_csk(sk);
1070
-
1071
-	if (icsk->icsk_af_ops->compat_getsockopt)
1072
-		return icsk->icsk_af_ops->compat_getsockopt(sk, level, optname,
1073
-							    optval, optlen);
1074
-	return icsk->icsk_af_ops->getsockopt(sk, level, optname,
1075
-					     optval, optlen);
1076
-}
1077
-EXPORT_SYMBOL_GPL(inet_csk_compat_getsockopt);
1078
-
1079
-int inet_csk_compat_setsockopt(struct sock *sk, int level, int optname,
1080
-			       char __user *optval, unsigned int optlen)
1081
-{
1082
-	const struct inet_connection_sock *icsk = inet_csk(sk);
1083
-
1084
-	if (icsk->icsk_af_ops->compat_setsockopt)
1085
-		return icsk->icsk_af_ops->compat_setsockopt(sk, level, optname,
1086
-							    optval, optlen);
1087
-	return icsk->icsk_af_ops->setsockopt(sk, level, optname,
1088
-					     optval, optlen);
1089
-}
1090
-EXPORT_SYMBOL_GPL(inet_csk_compat_setsockopt);
1091
-#endif
10921072 
10931073 static struct dst_entry *inet_csk_rebuild_route(struct sock *sk, struct flowi *fl)
10941074 {