1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * INET		An implementation of the TCP/IP protocol suite for the LINUX
4  *		operating system.  INET is implemented using the  BSD Socket
5  *		interface as the means of communication with the user level.
6  *
7  *		Generic TIME_WAIT sockets functions
8  *
9  *		From code orinally in TCP
10  */
11 
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <net/inet_hashtables.h>
16 #include <net/inet_timewait_sock.h>
17 #include <net/ip.h>
18 
19 
20 /**
21  *	inet_twsk_bind_unhash - unhash a timewait socket from bind hash
22  *	@tw: timewait socket
23  *	@hashinfo: hashinfo pointer
24  *
25  *	unhash a timewait socket from bind hash, if hashed.
26  *	bind hash lock must be held by caller.
27  *	Returns 1 if caller should call inet_twsk_put() after lock release.
28  */
inet_twsk_bind_unhash(struct inet_timewait_sock * tw,struct inet_hashinfo * hashinfo)29 void inet_twsk_bind_unhash(struct inet_timewait_sock *tw,
30 			  struct inet_hashinfo *hashinfo)
31 {
32 	struct inet_bind_bucket *tb = tw->tw_tb;
33 
34 	if (!tb)
35 		return;
36 
37 	__hlist_del(&tw->tw_bind_node);
38 	tw->tw_tb = NULL;
39 	inet_bind_bucket_destroy(hashinfo->bind_bucket_cachep, tb);
40 	__sock_put((struct sock *)tw);
41 }
42 
43 /* Must be called with locally disabled BHs. */
inet_twsk_kill(struct inet_timewait_sock * tw)44 static void inet_twsk_kill(struct inet_timewait_sock *tw)
45 {
46 	struct inet_hashinfo *hashinfo = tw->tw_dr->hashinfo;
47 	spinlock_t *lock = inet_ehash_lockp(hashinfo, tw->tw_hash);
48 	struct inet_bind_hashbucket *bhead;
49 
50 	spin_lock(lock);
51 	sk_nulls_del_node_init_rcu((struct sock *)tw);
52 	spin_unlock(lock);
53 
54 	/* Disassociate with bind bucket. */
55 	bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), tw->tw_num,
56 			hashinfo->bhash_size)];
57 
58 	spin_lock(&bhead->lock);
59 	inet_twsk_bind_unhash(tw, hashinfo);
60 	spin_unlock(&bhead->lock);
61 
62 	if (refcount_dec_and_test(&tw->tw_dr->tw_refcount))
63 		kfree(tw->tw_dr);
64 
65 	inet_twsk_put(tw);
66 }
67 
inet_twsk_free(struct inet_timewait_sock * tw)68 void inet_twsk_free(struct inet_timewait_sock *tw)
69 {
70 	struct module *owner = tw->tw_prot->owner;
71 	twsk_destructor((struct sock *)tw);
72 #ifdef SOCK_REFCNT_DEBUG
73 	pr_debug("%s timewait_sock %p released\n", tw->tw_prot->name, tw);
74 #endif
75 	kmem_cache_free(tw->tw_prot->twsk_prot->twsk_slab, tw);
76 	module_put(owner);
77 }
78 
inet_twsk_put(struct inet_timewait_sock * tw)79 void inet_twsk_put(struct inet_timewait_sock *tw)
80 {
81 	if (refcount_dec_and_test(&tw->tw_refcnt))
82 		inet_twsk_free(tw);
83 }
84 EXPORT_SYMBOL_GPL(inet_twsk_put);
85 
inet_twsk_add_node_rcu(struct inet_timewait_sock * tw,struct hlist_nulls_head * list)86 static void inet_twsk_add_node_rcu(struct inet_timewait_sock *tw,
87 				   struct hlist_nulls_head *list)
88 {
89 	hlist_nulls_add_head_rcu(&tw->tw_node, list);
90 }
91 
inet_twsk_add_bind_node(struct inet_timewait_sock * tw,struct hlist_head * list)92 static void inet_twsk_add_bind_node(struct inet_timewait_sock *tw,
93 				    struct hlist_head *list)
94 {
95 	hlist_add_head(&tw->tw_bind_node, list);
96 }
97 
98 /*
99  * Enter the time wait state. This is called with locally disabled BH.
100  * Essentially we whip up a timewait bucket, copy the relevant info into it
101  * from the SK, and mess with hash chains and list linkage.
102  */
inet_twsk_hashdance(struct inet_timewait_sock * tw,struct sock * sk,struct inet_hashinfo * hashinfo)103 void inet_twsk_hashdance(struct inet_timewait_sock *tw, struct sock *sk,
104 			   struct inet_hashinfo *hashinfo)
105 {
106 	const struct inet_sock *inet = inet_sk(sk);
107 	const struct inet_connection_sock *icsk = inet_csk(sk);
108 	struct inet_ehash_bucket *ehead = inet_ehash_bucket(hashinfo, sk->sk_hash);
109 	spinlock_t *lock = inet_ehash_lockp(hashinfo, sk->sk_hash);
110 	struct inet_bind_hashbucket *bhead;
111 	/* Step 1: Put TW into bind hash. Original socket stays there too.
112 	   Note, that any socket with inet->num != 0 MUST be bound in
113 	   binding cache, even if it is closed.
114 	 */
115 	bhead = &hashinfo->bhash[inet_bhashfn(twsk_net(tw), inet->inet_num,
116 			hashinfo->bhash_size)];
117 	spin_lock(&bhead->lock);
118 	tw->tw_tb = icsk->icsk_bind_hash;
119 	WARN_ON(!icsk->icsk_bind_hash);
120 	inet_twsk_add_bind_node(tw, &tw->tw_tb->owners);
121 	spin_unlock(&bhead->lock);
122 
123 	spin_lock(lock);
124 
125 	inet_twsk_add_node_rcu(tw, &ehead->chain);
126 
127 	/* Step 3: Remove SK from hash chain */
128 	if (__sk_nulls_del_node_init_rcu(sk))
129 		sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
130 
131 	spin_unlock(lock);
132 
133 	/* tw_refcnt is set to 3 because we have :
134 	 * - one reference for bhash chain.
135 	 * - one reference for ehash chain.
136 	 * - one reference for timer.
137 	 * We can use atomic_set() because prior spin_lock()/spin_unlock()
138 	 * committed into memory all tw fields.
139 	 * Also note that after this point, we lost our implicit reference
140 	 * so we are not allowed to use tw anymore.
141 	 */
142 	refcount_set(&tw->tw_refcnt, 3);
143 }
144 EXPORT_SYMBOL_GPL(inet_twsk_hashdance);
145 
tw_timer_handler(struct timer_list * t)146 static void tw_timer_handler(struct timer_list *t)
147 {
148 	struct inet_timewait_sock *tw = from_timer(tw, t, tw_timer);
149 
150 	inet_twsk_kill(tw);
151 }
152 
inet_twsk_alloc(const struct sock * sk,struct inet_timewait_death_row * dr,const int state)153 struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk,
154 					   struct inet_timewait_death_row *dr,
155 					   const int state)
156 {
157 	struct inet_timewait_sock *tw;
158 
159 	if (refcount_read(&dr->tw_refcount) - 1 >=
160 	    READ_ONCE(dr->sysctl_max_tw_buckets))
161 		return NULL;
162 
163 	tw = kmem_cache_alloc(sk->sk_prot_creator->twsk_prot->twsk_slab,
164 			      GFP_ATOMIC);
165 	if (tw) {
166 		const struct inet_sock *inet = inet_sk(sk);
167 
168 		tw->tw_dr	    = dr;
169 		/* Give us an identity. */
170 		tw->tw_daddr	    = inet->inet_daddr;
171 		tw->tw_rcv_saddr    = inet->inet_rcv_saddr;
172 		tw->tw_bound_dev_if = sk->sk_bound_dev_if;
173 		tw->tw_tos	    = inet->tos;
174 		tw->tw_num	    = inet->inet_num;
175 		tw->tw_state	    = TCP_TIME_WAIT;
176 		tw->tw_substate	    = state;
177 		tw->tw_sport	    = inet->inet_sport;
178 		tw->tw_dport	    = inet->inet_dport;
179 		tw->tw_family	    = sk->sk_family;
180 		tw->tw_reuse	    = sk->sk_reuse;
181 		tw->tw_reuseport    = sk->sk_reuseport;
182 		tw->tw_hash	    = sk->sk_hash;
183 		tw->tw_ipv6only	    = 0;
184 		tw->tw_transparent  = inet->transparent;
185 		tw->tw_prot	    = sk->sk_prot_creator;
186 		atomic64_set(&tw->tw_cookie, atomic64_read(&sk->sk_cookie));
187 		twsk_net_set(tw, sock_net(sk));
188 		timer_setup(&tw->tw_timer, tw_timer_handler, TIMER_PINNED);
189 		/*
190 		 * Because we use RCU lookups, we should not set tw_refcnt
191 		 * to a non null value before everything is setup for this
192 		 * timewait socket.
193 		 */
194 		refcount_set(&tw->tw_refcnt, 0);
195 
196 		__module_get(tw->tw_prot->owner);
197 	}
198 
199 	return tw;
200 }
201 EXPORT_SYMBOL_GPL(inet_twsk_alloc);
202 
203 /* These are always called from BH context.  See callers in
204  * tcp_input.c to verify this.
205  */
206 
207 /* This is for handling early-kills of TIME_WAIT sockets.
208  * Warning : consume reference.
209  * Caller should not access tw anymore.
210  */
inet_twsk_deschedule_put(struct inet_timewait_sock * tw)211 void inet_twsk_deschedule_put(struct inet_timewait_sock *tw)
212 {
213 	if (del_timer_sync(&tw->tw_timer))
214 		inet_twsk_kill(tw);
215 	inet_twsk_put(tw);
216 }
217 EXPORT_SYMBOL(inet_twsk_deschedule_put);
218 
__inet_twsk_schedule(struct inet_timewait_sock * tw,int timeo,bool rearm)219 void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo, bool rearm)
220 {
221 	/* timeout := RTO * 3.5
222 	 *
223 	 * 3.5 = 1+2+0.5 to wait for two retransmits.
224 	 *
225 	 * RATIONALE: if FIN arrived and we entered TIME-WAIT state,
226 	 * our ACK acking that FIN can be lost. If N subsequent retransmitted
227 	 * FINs (or previous seqments) are lost (probability of such event
228 	 * is p^(N+1), where p is probability to lose single packet and
229 	 * time to detect the loss is about RTO*(2^N - 1) with exponential
230 	 * backoff). Normal timewait length is calculated so, that we
231 	 * waited at least for one retransmitted FIN (maximal RTO is 120sec).
232 	 * [ BTW Linux. following BSD, violates this requirement waiting
233 	 *   only for 60sec, we should wait at least for 240 secs.
234 	 *   Well, 240 consumes too much of resources 8)
235 	 * ]
236 	 * This interval is not reduced to catch old duplicate and
237 	 * responces to our wandering segments living for two MSLs.
238 	 * However, if we use PAWS to detect
239 	 * old duplicates, we can reduce the interval to bounds required
240 	 * by RTO, rather than MSL. So, if peer understands PAWS, we
241 	 * kill tw bucket after 3.5*RTO (it is important that this number
242 	 * is greater than TS tick!) and detect old duplicates with help
243 	 * of PAWS.
244 	 */
245 
246 	if (!rearm) {
247 		bool kill = timeo <= 4*HZ;
248 
249 		__NET_INC_STATS(twsk_net(tw), kill ? LINUX_MIB_TIMEWAITKILLED :
250 						     LINUX_MIB_TIMEWAITED);
251 		BUG_ON(mod_timer(&tw->tw_timer, jiffies + timeo));
252 		refcount_inc(&tw->tw_dr->tw_refcount);
253 	} else {
254 		mod_timer_pending(&tw->tw_timer, jiffies + timeo);
255 	}
256 }
257 EXPORT_SYMBOL_GPL(__inet_twsk_schedule);
258 
inet_twsk_purge(struct inet_hashinfo * hashinfo,int family)259 void inet_twsk_purge(struct inet_hashinfo *hashinfo, int family)
260 {
261 	struct inet_timewait_sock *tw;
262 	struct sock *sk;
263 	struct hlist_nulls_node *node;
264 	unsigned int slot;
265 
266 	for (slot = 0; slot <= hashinfo->ehash_mask; slot++) {
267 		struct inet_ehash_bucket *head = &hashinfo->ehash[slot];
268 restart_rcu:
269 		cond_resched();
270 		rcu_read_lock();
271 restart:
272 		sk_nulls_for_each_rcu(sk, node, &head->chain) {
273 			if (sk->sk_state != TCP_TIME_WAIT)
274 				continue;
275 			tw = inet_twsk(sk);
276 			if ((tw->tw_family != family) ||
277 				refcount_read(&twsk_net(tw)->ns.count))
278 				continue;
279 
280 			if (unlikely(!refcount_inc_not_zero(&tw->tw_refcnt)))
281 				continue;
282 
283 			if (unlikely((tw->tw_family != family) ||
284 				     refcount_read(&twsk_net(tw)->ns.count))) {
285 				inet_twsk_put(tw);
286 				goto restart;
287 			}
288 
289 			rcu_read_unlock();
290 			local_bh_disable();
291 			inet_twsk_deschedule_put(tw);
292 			local_bh_enable();
293 			goto restart_rcu;
294 		}
295 		/* If the nulls value we got at the end of this lookup is
296 		 * not the expected one, we must restart lookup.
297 		 * We probably met an item that was moved to another chain.
298 		 */
299 		if (get_nulls_value(node) != slot)
300 			goto restart;
301 		rcu_read_unlock();
302 	}
303 }
304 EXPORT_SYMBOL_GPL(inet_twsk_purge);
305