Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
4 : : * operating system. INET is implemented using the BSD Socket
5 : : * interface as the means of communication with the user level.
6 : : *
7 : : * Implementation of the Transmission Control Protocol(TCP).
8 : : *
9 : : * Authors: Ross Biro
10 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
11 : : * Mark Evans, <evansmp@uhura.aston.ac.uk>
12 : : * Corey Minyard <wf-rch!minyard@relay.EU.net>
13 : : * Florian La Roche, <flla@stud.uni-sb.de>
14 : : * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
15 : : * Linus Torvalds, <torvalds@cs.helsinki.fi>
16 : : * Alan Cox, <gw4pts@gw4pts.ampr.org>
17 : : * Matthew Dillon, <dillon@apollo.west.oic.com>
18 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
19 : : * Jorge Cwik, <jorge@laser.satlink.net>
20 : : *
21 : : * Fixes:
22 : : * Alan Cox : Numerous verify_area() calls
23 : : * Alan Cox : Set the ACK bit on a reset
24 : : * Alan Cox : Stopped it crashing if it closed while
25 : : * sk->inuse=1 and was trying to connect
26 : : * (tcp_err()).
27 : : * Alan Cox : All icmp error handling was broken
28 : : * pointers passed where wrong and the
29 : : * socket was looked up backwards. Nobody
30 : : * tested any icmp error code obviously.
31 : : * Alan Cox : tcp_err() now handled properly. It
32 : : * wakes people on errors. poll
33 : : * behaves and the icmp error race
34 : : * has gone by moving it into sock.c
35 : : * Alan Cox : tcp_send_reset() fixed to work for
36 : : * everything not just packets for
37 : : * unknown sockets.
38 : : * Alan Cox : tcp option processing.
39 : : * Alan Cox : Reset tweaked (still not 100%) [Had
40 : : * syn rule wrong]
41 : : * Herp Rosmanith : More reset fixes
42 : : * Alan Cox : No longer acks invalid rst frames.
43 : : * Acking any kind of RST is right out.
44 : : * Alan Cox : Sets an ignore me flag on an rst
45 : : * receive otherwise odd bits of prattle
46 : : * escape still
47 : : * Alan Cox : Fixed another acking RST frame bug.
48 : : * Should stop LAN workplace lockups.
49 : : * Alan Cox : Some tidyups using the new skb list
50 : : * facilities
51 : : * Alan Cox : sk->keepopen now seems to work
52 : : * Alan Cox : Pulls options out correctly on accepts
53 : : * Alan Cox : Fixed assorted sk->rqueue->next errors
54 : : * Alan Cox : PSH doesn't end a TCP read. Switched a
55 : : * bit to skb ops.
56 : : * Alan Cox : Tidied tcp_data to avoid a potential
57 : : * nasty.
58 : : * Alan Cox : Added some better commenting, as the
59 : : * tcp is hard to follow
60 : : * Alan Cox : Removed incorrect check for 20 * psh
61 : : * Michael O'Reilly : ack < copied bug fix.
62 : : * Johannes Stille : Misc tcp fixes (not all in yet).
63 : : * Alan Cox : FIN with no memory -> CRASH
64 : : * Alan Cox : Added socket option proto entries.
65 : : * Also added awareness of them to accept.
66 : : * Alan Cox : Added TCP options (SOL_TCP)
67 : : * Alan Cox : Switched wakeup calls to callbacks,
68 : : * so the kernel can layer network
69 : : * sockets.
70 : : * Alan Cox : Use ip_tos/ip_ttl settings.
71 : : * Alan Cox : Handle FIN (more) properly (we hope).
72 : : * Alan Cox : RST frames sent on unsynchronised
73 : : * state ack error.
74 : : * Alan Cox : Put in missing check for SYN bit.
75 : : * Alan Cox : Added tcp_select_window() aka NET2E
76 : : * window non shrink trick.
77 : : * Alan Cox : Added a couple of small NET2E timer
78 : : * fixes
79 : : * Charles Hedrick : TCP fixes
80 : : * Toomas Tamm : TCP window fixes
81 : : * Alan Cox : Small URG fix to rlogin ^C ack fight
82 : : * Charles Hedrick : Rewrote most of it to actually work
83 : : * Linus : Rewrote tcp_read() and URG handling
84 : : * completely
85 : : * Gerhard Koerting: Fixed some missing timer handling
86 : : * Matthew Dillon : Reworked TCP machine states as per RFC
87 : : * Gerhard Koerting: PC/TCP workarounds
88 : : * Adam Caldwell : Assorted timer/timing errors
89 : : * Matthew Dillon : Fixed another RST bug
90 : : * Alan Cox : Move to kernel side addressing changes.
91 : : * Alan Cox : Beginning work on TCP fastpathing
92 : : * (not yet usable)
93 : : * Arnt Gulbrandsen: Turbocharged tcp_check() routine.
94 : : * Alan Cox : TCP fast path debugging
95 : : * Alan Cox : Window clamping
96 : : * Michael Riepe : Bug in tcp_check()
97 : : * Matt Dillon : More TCP improvements and RST bug fixes
98 : : * Matt Dillon : Yet more small nasties remove from the
99 : : * TCP code (Be very nice to this man if
100 : : * tcp finally works 100%) 8)
101 : : * Alan Cox : BSD accept semantics.
102 : : * Alan Cox : Reset on closedown bug.
103 : : * Peter De Schrijver : ENOTCONN check missing in tcp_sendto().
104 : : * Michael Pall : Handle poll() after URG properly in
105 : : * all cases.
106 : : * Michael Pall : Undo the last fix in tcp_read_urg()
107 : : * (multi URG PUSH broke rlogin).
108 : : * Michael Pall : Fix the multi URG PUSH problem in
109 : : * tcp_readable(), poll() after URG
110 : : * works now.
111 : : * Michael Pall : recv(...,MSG_OOB) never blocks in the
112 : : * BSD api.
113 : : * Alan Cox : Changed the semantics of sk->socket to
114 : : * fix a race and a signal problem with
115 : : * accept() and async I/O.
116 : : * Alan Cox : Relaxed the rules on tcp_sendto().
117 : : * Yury Shevchuk : Really fixed accept() blocking problem.
118 : : * Craig I. Hagan : Allow for BSD compatible TIME_WAIT for
119 : : * clients/servers which listen in on
120 : : * fixed ports.
121 : : * Alan Cox : Cleaned the above up and shrank it to
122 : : * a sensible code size.
123 : : * Alan Cox : Self connect lockup fix.
124 : : * Alan Cox : No connect to multicast.
125 : : * Ross Biro : Close unaccepted children on master
126 : : * socket close.
127 : : * Alan Cox : Reset tracing code.
128 : : * Alan Cox : Spurious resets on shutdown.
129 : : * Alan Cox : Giant 15 minute/60 second timer error
130 : : * Alan Cox : Small whoops in polling before an
131 : : * accept.
132 : : * Alan Cox : Kept the state trace facility since
133 : : * it's handy for debugging.
134 : : * Alan Cox : More reset handler fixes.
135 : : * Alan Cox : Started rewriting the code based on
136 : : * the RFC's for other useful protocol
137 : : * references see: Comer, KA9Q NOS, and
138 : : * for a reference on the difference
139 : : * between specifications and how BSD
140 : : * works see the 4.4lite source.
141 : : * A.N.Kuznetsov : Don't time wait on completion of tidy
142 : : * close.
143 : : * Linus Torvalds : Fin/Shutdown & copied_seq changes.
144 : : * Linus Torvalds : Fixed BSD port reuse to work first syn
145 : : * Alan Cox : Reimplemented timers as per the RFC
146 : : * and using multiple timers for sanity.
147 : : * Alan Cox : Small bug fixes, and a lot of new
148 : : * comments.
149 : : * Alan Cox : Fixed dual reader crash by locking
150 : : * the buffers (much like datagram.c)
151 : : * Alan Cox : Fixed stuck sockets in probe. A probe
152 : : * now gets fed up of retrying without
153 : : * (even a no space) answer.
154 : : * Alan Cox : Extracted closing code better
155 : : * Alan Cox : Fixed the closing state machine to
156 : : * resemble the RFC.
157 : : * Alan Cox : More 'per spec' fixes.
158 : : * Jorge Cwik : Even faster checksumming.
159 : : * Alan Cox : tcp_data() doesn't ack illegal PSH
160 : : * only frames. At least one pc tcp stack
161 : : * generates them.
162 : : * Alan Cox : Cache last socket.
163 : : * Alan Cox : Per route irtt.
164 : : * Matt Day : poll()->select() match BSD precisely on error
165 : : * Alan Cox : New buffers
166 : : * Marc Tamsky : Various sk->prot->retransmits and
167 : : * sk->retransmits misupdating fixed.
168 : : * Fixed tcp_write_timeout: stuck close,
169 : : * and TCP syn retries gets used now.
170 : : * Mark Yarvis : In tcp_read_wakeup(), don't send an
171 : : * ack if state is TCP_CLOSED.
172 : : * Alan Cox : Look up device on a retransmit - routes may
173 : : * change. Doesn't yet cope with MSS shrink right
174 : : * but it's a start!
175 : : * Marc Tamsky : Closing in closing fixes.
176 : : * Mike Shaver : RFC1122 verifications.
177 : : * Alan Cox : rcv_saddr errors.
178 : : * Alan Cox : Block double connect().
179 : : * Alan Cox : Small hooks for enSKIP.
180 : : * Alexey Kuznetsov: Path MTU discovery.
181 : : * Alan Cox : Support soft errors.
182 : : * Alan Cox : Fix MTU discovery pathological case
183 : : * when the remote claims no mtu!
184 : : * Marc Tamsky : TCP_CLOSE fix.
185 : : * Colin (G3TNE) : Send a reset on syn ack replies in
186 : : * window but wrong (fixes NT lpd problems)
187 : : * Pedro Roque : Better TCP window handling, delayed ack.
188 : : * Joerg Reuter : No modification of locked buffers in
189 : : * tcp_do_retransmit()
190 : : * Eric Schenk : Changed receiver side silly window
191 : : * avoidance algorithm to BSD style
192 : : * algorithm. This doubles throughput
193 : : * against machines running Solaris,
194 : : * and seems to result in general
195 : : * improvement.
196 : : * Stefan Magdalinski : adjusted tcp_readable() to fix FIONREAD
197 : : * Willy Konynenberg : Transparent proxying support.
198 : : * Mike McLagan : Routing by source
199 : : * Keith Owens : Do proper merging with partial SKB's in
200 : : * tcp_do_sendmsg to avoid burstiness.
201 : : * Eric Schenk : Fix fast close down bug with
202 : : * shutdown() followed by close().
203 : : * Andi Kleen : Make poll agree with SIGIO
204 : : * Salvatore Sanfilippo : Support SO_LINGER with linger == 1 and
205 : : * lingertime == 0 (RFC 793 ABORT Call)
206 : : * Hirokazu Takahashi : Use copy_from_user() instead of
207 : : * csum_and_copy_from_user() if possible.
208 : : *
209 : : * Description of States:
210 : : *
211 : : * TCP_SYN_SENT sent a connection request, waiting for ack
212 : : *
213 : : * TCP_SYN_RECV received a connection request, sent ack,
214 : : * waiting for final ack in three-way handshake.
215 : : *
216 : : * TCP_ESTABLISHED connection established
217 : : *
218 : : * TCP_FIN_WAIT1 our side has shutdown, waiting to complete
219 : : * transmission of remaining buffered data
220 : : *
221 : : * TCP_FIN_WAIT2 all buffered data sent, waiting for remote
222 : : * to shutdown
223 : : *
224 : : * TCP_CLOSING both sides have shutdown but we still have
225 : : * data we have to finish sending
226 : : *
227 : : * TCP_TIME_WAIT timeout to catch resent junk before entering
228 : : * closed, can only be entered from FIN_WAIT2
229 : : * or CLOSING. Required because the other end
230 : : * may not have gotten our last ACK causing it
231 : : * to retransmit the data packet (which we ignore)
232 : : *
233 : : * TCP_CLOSE_WAIT remote side has shutdown and is waiting for
234 : : * us to finish writing our data and to shutdown
235 : : * (we have to close() to move on to LAST_ACK)
236 : : *
237 : : * TCP_LAST_ACK out side has shutdown after remote has
238 : : * shutdown. There may still be data in our
239 : : * buffer that we have to finish sending
240 : : *
241 : : * TCP_CLOSE socket is finished
242 : : */
243 : :
244 : : #define pr_fmt(fmt) "TCP: " fmt
245 : :
246 : : #include <crypto/hash.h>
247 : : #include <linux/kernel.h>
248 : : #include <linux/module.h>
249 : : #include <linux/types.h>
250 : : #include <linux/fcntl.h>
251 : : #include <linux/poll.h>
252 : : #include <linux/inet_diag.h>
253 : : #include <linux/init.h>
254 : : #include <linux/fs.h>
255 : : #include <linux/skbuff.h>
256 : : #include <linux/scatterlist.h>
257 : : #include <linux/splice.h>
258 : : #include <linux/net.h>
259 : : #include <linux/socket.h>
260 : : #include <linux/random.h>
261 : : #include <linux/memblock.h>
262 : : #include <linux/highmem.h>
263 : : #include <linux/swap.h>
264 : : #include <linux/cache.h>
265 : : #include <linux/err.h>
266 : : #include <linux/time.h>
267 : : #include <linux/slab.h>
268 : : #include <linux/errqueue.h>
269 : : #include <linux/static_key.h>
270 : :
271 : : #include <net/icmp.h>
272 : : #include <net/inet_common.h>
273 : : #include <net/tcp.h>
274 : : #include <net/xfrm.h>
275 : : #include <net/ip.h>
276 : : #include <net/sock.h>
277 : :
278 : : #include <linux/uaccess.h>
279 : : #include <asm/ioctls.h>
280 : : #include <net/busy_poll.h>
281 : :
282 : : struct percpu_counter tcp_orphan_count;
283 : : EXPORT_SYMBOL_GPL(tcp_orphan_count);
284 : :
285 : : long sysctl_tcp_mem[3] __read_mostly;
286 : : EXPORT_SYMBOL(sysctl_tcp_mem);
287 : :
288 : : atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
289 : : EXPORT_SYMBOL(tcp_memory_allocated);
290 : :
291 : : #if IS_ENABLED(CONFIG_SMC)
292 : : DEFINE_STATIC_KEY_FALSE(tcp_have_smc);
293 : : EXPORT_SYMBOL(tcp_have_smc);
294 : : #endif
295 : :
296 : : /*
297 : : * Current number of TCP sockets.
298 : : */
299 : : struct percpu_counter tcp_sockets_allocated;
300 : : EXPORT_SYMBOL(tcp_sockets_allocated);
301 : :
302 : : /*
303 : : * TCP splice context
304 : : */
305 : : struct tcp_splice_state {
306 : : struct pipe_inode_info *pipe;
307 : : size_t len;
308 : : unsigned int flags;
309 : : };
310 : :
311 : : /*
312 : : * Pressure flag: try to collapse.
313 : : * Technical note: it is used by multiple contexts non atomically.
314 : : * All the __sk_mem_schedule() is of this nature: accounting
315 : : * is strict, actions are advisory and have some latency.
316 : : */
317 : : unsigned long tcp_memory_pressure __read_mostly;
318 : : EXPORT_SYMBOL_GPL(tcp_memory_pressure);
319 : :
320 : : DEFINE_STATIC_KEY_FALSE(tcp_rx_skb_cache_key);
321 : : EXPORT_SYMBOL(tcp_rx_skb_cache_key);
322 : :
323 : : DEFINE_STATIC_KEY_FALSE(tcp_tx_skb_cache_key);
324 : :
325 : 0 : void tcp_enter_memory_pressure(struct sock *sk)
326 : : {
327 : : unsigned long val;
328 : :
329 : 0 : if (READ_ONCE(tcp_memory_pressure))
330 : 0 : return;
331 : 0 : val = jiffies;
332 : :
333 : 0 : if (!val)
334 : 0 : val--;
335 : 0 : if (!cmpxchg(&tcp_memory_pressure, 0, val))
336 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
337 : : }
338 : : EXPORT_SYMBOL_GPL(tcp_enter_memory_pressure);
339 : :
340 : 1 : void tcp_leave_memory_pressure(struct sock *sk)
341 : : {
342 : : unsigned long val;
343 : :
344 : 1 : if (!READ_ONCE(tcp_memory_pressure))
345 : 1 : return;
346 : 0 : val = xchg(&tcp_memory_pressure, 0);
347 : 0 : if (val)
348 : 0 : NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURESCHRONO,
349 : : jiffies_to_msecs(jiffies - val));
350 : : }
351 : : EXPORT_SYMBOL_GPL(tcp_leave_memory_pressure);
352 : :
353 : : /* Convert seconds to retransmits based on initial and max timeout */
354 : : static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
355 : : {
356 : : u8 res = 0;
357 : :
358 : 0 : if (seconds > 0) {
359 : : int period = timeout;
360 : :
361 : : res = 1;
362 : 0 : while (seconds > period && res < 255) {
363 : 0 : res++;
364 : 0 : timeout <<= 1;
365 : 0 : if (timeout > rto_max)
366 : : timeout = rto_max;
367 : 0 : period += timeout;
368 : : }
369 : : }
370 : : return res;
371 : : }
372 : :
373 : : /* Convert retransmits to seconds based on initial and max timeout */
374 : : static int retrans_to_secs(u8 retrans, int timeout, int rto_max)
375 : : {
376 : : int period = 0;
377 : :
378 : 0 : if (retrans > 0) {
379 : : period = timeout;
380 : 0 : while (--retrans) {
381 : 0 : timeout <<= 1;
382 : 0 : if (timeout > rto_max)
383 : : timeout = rto_max;
384 : 0 : period += timeout;
385 : : }
386 : : }
387 : : return period;
388 : : }
389 : :
390 : 1 : static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp)
391 : : {
392 : : u32 rate = READ_ONCE(tp->rate_delivered);
393 : : u32 intv = READ_ONCE(tp->rate_interval_us);
394 : 1 : u64 rate64 = 0;
395 : :
396 : 1 : if (rate && intv) {
397 : 1 : rate64 = (u64)rate * tp->mss_cache * USEC_PER_SEC;
398 : 1 : do_div(rate64, intv);
399 : : }
400 : 1 : return rate64;
401 : : }
402 : :
403 : : /* Address-family independent initialization for a tcp_sock.
404 : : *
405 : : * NOTE: A lot of things set to zero explicitly by call to
406 : : * sk_alloc() so need not be done here.
407 : : */
408 : 1 : void tcp_init_sock(struct sock *sk)
409 : : {
410 : : struct inet_connection_sock *icsk = inet_csk(sk);
411 : : struct tcp_sock *tp = tcp_sk(sk);
412 : :
413 : 1 : tp->out_of_order_queue = RB_ROOT;
414 : 1 : sk->tcp_rtx_queue = RB_ROOT;
415 : 1 : tcp_init_xmit_timers(sk);
416 : 1 : INIT_LIST_HEAD(&tp->tsq_node);
417 : 1 : INIT_LIST_HEAD(&tp->tsorted_sent_queue);
418 : :
419 : 1 : icsk->icsk_rto = TCP_TIMEOUT_INIT;
420 : 1 : tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
421 : 1 : minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U);
422 : :
423 : : /* So many TCP implementations out there (incorrectly) count the
424 : : * initial SYN frame in their delayed-ACK and congestion control
425 : : * algorithms that we must have the following bandaid to talk
426 : : * efficiently to them. -DaveM
427 : : */
428 : 1 : tp->snd_cwnd = TCP_INIT_CWND;
429 : :
430 : : /* There's a bubble in the pipe until at least the first ACK. */
431 : 1 : tp->app_limited = ~0U;
432 : :
433 : : /* See draft-stevens-tcpca-spec-01 for discussion of the
434 : : * initialization of these values.
435 : : */
436 : 1 : tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
437 : 1 : tp->snd_cwnd_clamp = ~0;
438 : 1 : tp->mss_cache = TCP_MSS_DEFAULT;
439 : :
440 : 1 : tp->reordering = sock_net(sk)->ipv4.sysctl_tcp_reordering;
441 : 1 : tcp_assign_congestion_control(sk);
442 : :
443 : 1 : tp->tsoffset = 0;
444 : 1 : tp->rack.reo_wnd_steps = 1;
445 : :
446 : 1 : sk->sk_state = TCP_CLOSE;
447 : :
448 : 1 : sk->sk_write_space = sk_stream_write_space;
449 : : sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
450 : :
451 : 1 : icsk->icsk_sync_mss = tcp_sync_mss;
452 : :
453 : 1 : WRITE_ONCE(sk->sk_sndbuf, sock_net(sk)->ipv4.sysctl_tcp_wmem[1]);
454 : 1 : WRITE_ONCE(sk->sk_rcvbuf, sock_net(sk)->ipv4.sysctl_tcp_rmem[1]);
455 : :
456 : 1 : sk_sockets_allocated_inc(sk);
457 : 1 : sk->sk_route_forced_caps = NETIF_F_GSO;
458 : 1 : }
459 : : EXPORT_SYMBOL(tcp_init_sock);
460 : :
461 : 1 : static void tcp_tx_timestamp(struct sock *sk, u16 tsflags)
462 : : {
463 : : struct sk_buff *skb = tcp_write_queue_tail(sk);
464 : :
465 : 1 : if (tsflags && skb) {
466 : : struct skb_shared_info *shinfo = skb_shinfo(skb);
467 : : struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
468 : :
469 : 0 : sock_tx_timestamp(sk, tsflags, &shinfo->tx_flags);
470 : 0 : if (tsflags & SOF_TIMESTAMPING_TX_ACK)
471 : 0 : tcb->txstamp_ack = 1;
472 : 0 : if (tsflags & SOF_TIMESTAMPING_TX_RECORD_MASK)
473 : 0 : shinfo->tskey = TCP_SKB_CB(skb)->seq + skb->len - 1;
474 : : }
475 : 1 : }
476 : :
477 : 1 : static inline bool tcp_stream_is_readable(const struct tcp_sock *tp,
478 : : int target, struct sock *sk)
479 : : {
480 : 1 : int avail = READ_ONCE(tp->rcv_nxt) - READ_ONCE(tp->copied_seq);
481 : :
482 : 1 : if (avail > 0) {
483 : 1 : if (avail >= target)
484 : : return true;
485 : 0 : if (tcp_rmem_pressure(sk))
486 : : return true;
487 : : }
488 : 1 : if (sk->sk_prot->stream_memory_read)
489 : 0 : return sk->sk_prot->stream_memory_read(sk);
490 : : return false;
491 : : }
492 : :
493 : : /*
494 : : * Wait for a TCP event.
495 : : *
496 : : * Note that we don't need to lock the socket, as the upper poll layers
497 : : * take care of normal races (between the test and the event) and we don't
498 : : * go look at any of the socket buffers directly.
499 : : */
500 : 1 : __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
501 : : {
502 : : __poll_t mask;
503 : 1 : struct sock *sk = sock->sk;
504 : : const struct tcp_sock *tp = tcp_sk(sk);
505 : : int state;
506 : :
507 : 1 : sock_poll_wait(file, sock, wait);
508 : :
509 : : state = inet_sk_state_load(sk);
510 : 1 : if (state == TCP_LISTEN)
511 : 0 : return inet_csk_listen_poll(sk);
512 : :
513 : : /* Socket is not locked. We are protected from async events
514 : : * by poll logic and correct handling of state changes
515 : : * made by other threads is impossible in any case.
516 : : */
517 : :
518 : : mask = 0;
519 : :
520 : : /*
521 : : * EPOLLHUP is certainly not done right. But poll() doesn't
522 : : * have a notion of HUP in just one direction, and for a
523 : : * socket the read side is more interesting.
524 : : *
525 : : * Some poll() documentation says that EPOLLHUP is incompatible
526 : : * with the EPOLLOUT/POLLWR flags, so somebody should check this
527 : : * all. But careful, it tends to be safer to return too many
528 : : * bits than too few, and you can easily break real applications
529 : : * if you don't tell them that something has hung up!
530 : : *
531 : : * Check-me.
532 : : *
533 : : * Check number 1. EPOLLHUP is _UNMASKABLE_ event (see UNIX98 and
534 : : * our fs/select.c). It means that after we received EOF,
535 : : * poll always returns immediately, making impossible poll() on write()
536 : : * in state CLOSE_WAIT. One solution is evident --- to set EPOLLHUP
537 : : * if and only if shutdown has been made in both directions.
538 : : * Actually, it is interesting to look how Solaris and DUX
539 : : * solve this dilemma. I would prefer, if EPOLLHUP were maskable,
540 : : * then we could set it on SND_SHUTDOWN. BTW examples given
541 : : * in Stevens' books assume exactly this behaviour, it explains
542 : : * why EPOLLHUP is incompatible with EPOLLOUT. --ANK
543 : : *
544 : : * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
545 : : * blocking on fresh not-connected or disconnected socket. --ANK
546 : : */
547 : 1 : if (sk->sk_shutdown == SHUTDOWN_MASK || state == TCP_CLOSE)
548 : : mask |= EPOLLHUP;
549 : 1 : if (sk->sk_shutdown & RCV_SHUTDOWN)
550 : 1 : mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
551 : :
552 : : /* Connected or passive Fast Open socket? */
553 : 1 : if (state != TCP_SYN_SENT &&
554 : 0 : (state != TCP_SYN_RECV || rcu_access_pointer(tp->fastopen_rsk))) {
555 : : int target = sock_rcvlowat(sk, 0, INT_MAX);
556 : :
557 : 1 : if (READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq) &&
558 : 0 : !sock_flag(sk, SOCK_URGINLINE) &&
559 : 0 : tp->urg_data)
560 : 0 : target++;
561 : :
562 : 1 : if (tcp_stream_is_readable(tp, target, sk))
563 : 1 : mask |= EPOLLIN | EPOLLRDNORM;
564 : :
565 : 1 : if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
566 : 1 : if (sk_stream_is_writeable(sk)) {
567 : 1 : mask |= EPOLLOUT | EPOLLWRNORM;
568 : : } else { /* send SIGIO later */
569 : 0 : sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
570 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
571 : :
572 : : /* Race breaker. If space is freed after
573 : : * wspace test but before the flags are set,
574 : : * IO signal will be lost. Memory barrier
575 : : * pairs with the input side.
576 : : */
577 : 0 : smp_mb__after_atomic();
578 : 0 : if (sk_stream_is_writeable(sk))
579 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
580 : : }
581 : : } else
582 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
583 : :
584 : 1 : if (tp->urg_data & TCP_URG_VALID)
585 : 0 : mask |= EPOLLPRI;
586 : 1 : } else if (state == TCP_SYN_SENT && inet_sk(sk)->defer_connect) {
587 : : /* Active TCP fastopen socket with defer_connect
588 : : * Return EPOLLOUT so application can call write()
589 : : * in order for kernel to generate SYN+data
590 : : */
591 : 0 : mask |= EPOLLOUT | EPOLLWRNORM;
592 : : }
593 : : /* This barrier is coupled with smp_wmb() in tcp_reset() */
594 : 1 : smp_rmb();
595 : 1 : if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
596 : 0 : mask |= EPOLLERR;
597 : :
598 : 1 : return mask;
599 : : }
600 : : EXPORT_SYMBOL(tcp_poll);
601 : :
602 : 0 : int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
603 : : {
604 : : struct tcp_sock *tp = tcp_sk(sk);
605 : : int answ;
606 : : bool slow;
607 : :
608 : 0 : switch (cmd) {
609 : : case SIOCINQ:
610 : 0 : if (sk->sk_state == TCP_LISTEN)
611 : : return -EINVAL;
612 : :
613 : 0 : slow = lock_sock_fast(sk);
614 : 0 : answ = tcp_inq(sk);
615 : : unlock_sock_fast(sk, slow);
616 : : break;
617 : : case SIOCATMARK:
618 : 0 : answ = tp->urg_data &&
619 : : READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq);
620 : 0 : break;
621 : : case SIOCOUTQ:
622 : 0 : if (sk->sk_state == TCP_LISTEN)
623 : : return -EINVAL;
624 : :
625 : 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
626 : : answ = 0;
627 : : else
628 : 0 : answ = READ_ONCE(tp->write_seq) - tp->snd_una;
629 : : break;
630 : : case SIOCOUTQNSD:
631 : 0 : if (sk->sk_state == TCP_LISTEN)
632 : : return -EINVAL;
633 : :
634 : 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
635 : : answ = 0;
636 : : else
637 : 0 : answ = READ_ONCE(tp->write_seq) -
638 : : READ_ONCE(tp->snd_nxt);
639 : : break;
640 : : default:
641 : : return -ENOIOCTLCMD;
642 : : }
643 : :
644 : 0 : return put_user(answ, (int __user *)arg);
645 : : }
646 : : EXPORT_SYMBOL(tcp_ioctl);
647 : :
648 : : static inline void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
649 : : {
650 : 1 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
651 : 1 : tp->pushed_seq = tp->write_seq;
652 : : }
653 : :
654 : : static inline bool forced_push(const struct tcp_sock *tp)
655 : : {
656 : 0 : return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
657 : : }
658 : :
659 : 1 : static void skb_entail(struct sock *sk, struct sk_buff *skb)
660 : : {
661 : : struct tcp_sock *tp = tcp_sk(sk);
662 : : struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
663 : :
664 : 1 : skb->csum = 0;
665 : 1 : tcb->seq = tcb->end_seq = tp->write_seq;
666 : 1 : tcb->tcp_flags = TCPHDR_ACK;
667 : 1 : tcb->sacked = 0;
668 : : __skb_header_release(skb);
669 : 1 : tcp_add_write_queue_tail(sk, skb);
670 : 1 : sk_wmem_queued_add(sk, skb->truesize);
671 : 1 : sk_mem_charge(sk, skb->truesize);
672 : 1 : if (tp->nonagle & TCP_NAGLE_PUSH)
673 : 1 : tp->nonagle &= ~TCP_NAGLE_PUSH;
674 : :
675 : 1 : tcp_slow_start_after_idle_check(sk);
676 : 1 : }
677 : :
678 : : static inline void tcp_mark_urg(struct tcp_sock *tp, int flags)
679 : : {
680 : 1 : if (flags & MSG_OOB)
681 : 0 : tp->snd_up = tp->write_seq;
682 : : }
683 : :
684 : : /* If a not yet filled skb is pushed, do not send it if
685 : : * we have data packets in Qdisc or NIC queues :
686 : : * Because TX completion will happen shortly, it gives a chance
687 : : * to coalesce future sendmsg() payload into this skb, without
688 : : * need for a timer, and with no latency trade off.
689 : : * As packets containing data payload have a bigger truesize
690 : : * than pure acks (dataless) packets, the last checks prevent
691 : : * autocorking if we only have an ACK in Qdisc/NIC queues,
692 : : * or if TX completion was delayed after we processed ACK packet.
693 : : */
694 : : static bool tcp_should_autocork(struct sock *sk, struct sk_buff *skb,
695 : : int size_goal)
696 : : {
697 : 1 : return skb->len < size_goal &&
698 : 1 : sock_net(sk)->ipv4.sysctl_tcp_autocorking &&
699 : 1 : !tcp_rtx_queue_empty(sk) &&
700 : 1 : refcount_read(&sk->sk_wmem_alloc) > skb->truesize;
701 : : }
702 : :
703 : 1 : static void tcp_push(struct sock *sk, int flags, int mss_now,
704 : : int nonagle, int size_goal)
705 : : {
706 : : struct tcp_sock *tp = tcp_sk(sk);
707 : : struct sk_buff *skb;
708 : :
709 : : skb = tcp_write_queue_tail(sk);
710 : 1 : if (!skb)
711 : : return;
712 : 1 : if (!(flags & MSG_MORE) || forced_push(tp))
713 : : tcp_mark_push(tp, skb);
714 : :
715 : : tcp_mark_urg(tp, flags);
716 : :
717 : 1 : if (tcp_should_autocork(sk, skb, size_goal)) {
718 : :
719 : : /* avoid atomic op if TSQ_THROTTLED bit is already set */
720 : 1 : if (!test_bit(TSQ_THROTTLED, &sk->sk_tsq_flags)) {
721 : 1 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPAUTOCORKING);
722 : 1 : set_bit(TSQ_THROTTLED, &sk->sk_tsq_flags);
723 : : }
724 : : /* It is possible TX completion already happened
725 : : * before we set TSQ_THROTTLED.
726 : : */
727 : 1 : if (refcount_read(&sk->sk_wmem_alloc) > skb->truesize)
728 : : return;
729 : : }
730 : :
731 : 1 : if (flags & MSG_MORE)
732 : : nonagle = TCP_NAGLE_CORK;
733 : :
734 : 1 : __tcp_push_pending_frames(sk, mss_now, nonagle);
735 : : }
736 : :
737 : 0 : static int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
738 : : unsigned int offset, size_t len)
739 : : {
740 : 0 : struct tcp_splice_state *tss = rd_desc->arg.data;
741 : : int ret;
742 : :
743 : 0 : ret = skb_splice_bits(skb, skb->sk, offset, tss->pipe,
744 : 0 : min(rd_desc->count, len), tss->flags);
745 : 0 : if (ret > 0)
746 : 0 : rd_desc->count -= ret;
747 : 0 : return ret;
748 : : }
749 : :
750 : 0 : static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
751 : : {
752 : : /* Store TCP splice context information in read_descriptor_t. */
753 : 0 : read_descriptor_t rd_desc = {
754 : : .arg.data = tss,
755 : 0 : .count = tss->len,
756 : : };
757 : :
758 : 0 : return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
759 : : }
760 : :
761 : : /**
762 : : * tcp_splice_read - splice data from TCP socket to a pipe
763 : : * @sock: socket to splice from
764 : : * @ppos: position (not valid)
765 : : * @pipe: pipe to splice to
766 : : * @len: number of bytes to splice
767 : : * @flags: splice modifier flags
768 : : *
769 : : * Description:
770 : : * Will read pages from given socket and fill them into a pipe.
771 : : *
772 : : **/
773 : 0 : ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
774 : : struct pipe_inode_info *pipe, size_t len,
775 : : unsigned int flags)
776 : : {
777 : 0 : struct sock *sk = sock->sk;
778 : 0 : struct tcp_splice_state tss = {
779 : : .pipe = pipe,
780 : : .len = len,
781 : : .flags = flags,
782 : : };
783 : : long timeo;
784 : : ssize_t spliced;
785 : : int ret;
786 : :
787 : 0 : sock_rps_record_flow(sk);
788 : : /*
789 : : * We can't seek on a socket input
790 : : */
791 : 0 : if (unlikely(*ppos))
792 : : return -ESPIPE;
793 : :
794 : : ret = spliced = 0;
795 : :
796 : : lock_sock(sk);
797 : :
798 : 0 : timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK);
799 : 0 : while (tss.len) {
800 : 0 : ret = __tcp_splice_read(sk, &tss);
801 : 0 : if (ret < 0)
802 : : break;
803 : 0 : else if (!ret) {
804 : 0 : if (spliced)
805 : : break;
806 : 0 : if (sock_flag(sk, SOCK_DONE))
807 : : break;
808 : 0 : if (sk->sk_err) {
809 : 0 : ret = sock_error(sk);
810 : 0 : break;
811 : : }
812 : 0 : if (sk->sk_shutdown & RCV_SHUTDOWN)
813 : : break;
814 : 0 : if (sk->sk_state == TCP_CLOSE) {
815 : : /*
816 : : * This occurs when user tries to read
817 : : * from never connected socket.
818 : : */
819 : : ret = -ENOTCONN;
820 : : break;
821 : : }
822 : 0 : if (!timeo) {
823 : : ret = -EAGAIN;
824 : : break;
825 : : }
826 : : /* if __tcp_splice_read() got nothing while we have
827 : : * an skb in receive queue, we do not want to loop.
828 : : * This might happen with URG data.
829 : : */
830 : 0 : if (!skb_queue_empty(&sk->sk_receive_queue))
831 : : break;
832 : 0 : sk_wait_data(sk, &timeo, NULL);
833 : 0 : if (signal_pending(current)) {
834 : 0 : ret = sock_intr_errno(timeo);
835 : 0 : break;
836 : : }
837 : 0 : continue;
838 : : }
839 : 0 : tss.len -= ret;
840 : 0 : spliced += ret;
841 : :
842 : 0 : if (!timeo)
843 : : break;
844 : 0 : release_sock(sk);
845 : : lock_sock(sk);
846 : :
847 : 0 : if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
848 : 0 : (sk->sk_shutdown & RCV_SHUTDOWN) ||
849 : 0 : signal_pending(current))
850 : : break;
851 : : }
852 : :
853 : 0 : release_sock(sk);
854 : :
855 : 0 : if (spliced)
856 : : return spliced;
857 : :
858 : 0 : return ret;
859 : : }
860 : : EXPORT_SYMBOL(tcp_splice_read);
861 : :
862 : 1 : struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
863 : : bool force_schedule)
864 : : {
865 : : struct sk_buff *skb;
866 : :
867 : 1 : if (likely(!size)) {
868 : 1 : skb = sk->sk_tx_skb_cache;
869 : 1 : if (skb) {
870 : 0 : skb->truesize = SKB_TRUESIZE(skb_end_offset(skb));
871 : 0 : sk->sk_tx_skb_cache = NULL;
872 : : pskb_trim(skb, 0);
873 : 0 : INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
874 : 0 : skb_shinfo(skb)->tx_flags = 0;
875 : 0 : memset(TCP_SKB_CB(skb), 0, sizeof(struct tcp_skb_cb));
876 : 0 : return skb;
877 : : }
878 : : }
879 : : /* The TCP header must be at least 32-bit aligned. */
880 : 1 : size = ALIGN(size, 4);
881 : :
882 : 1 : if (unlikely(tcp_under_memory_pressure(sk)))
883 : 0 : sk_mem_reclaim_partial(sk);
884 : :
885 : 1 : skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
886 : 1 : if (likely(skb)) {
887 : : bool mem_scheduled;
888 : :
889 : 1 : if (force_schedule) {
890 : : mem_scheduled = true;
891 : 1 : sk_forced_mem_schedule(sk, skb->truesize);
892 : : } else {
893 : 1 : mem_scheduled = sk_wmem_schedule(sk, skb->truesize);
894 : : }
895 : 1 : if (likely(mem_scheduled)) {
896 : 1 : skb_reserve(skb, sk->sk_prot->max_header);
897 : : /*
898 : : * Make sure that we have exactly size bytes
899 : : * available to the caller, no more, no less.
900 : : */
901 : 1 : skb->reserved_tailroom = skb->end - skb->tail - size;
902 : 1 : INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
903 : 1 : return skb;
904 : : }
905 : 0 : __kfree_skb(skb);
906 : : } else {
907 : 0 : sk->sk_prot->enter_memory_pressure(sk);
908 : : sk_stream_moderate_sndbuf(sk);
909 : : }
910 : : return NULL;
911 : : }
912 : :
913 : 1 : static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now,
914 : : int large_allowed)
915 : : {
916 : : struct tcp_sock *tp = tcp_sk(sk);
917 : : u32 new_size_goal, size_goal;
918 : :
919 : 1 : if (!large_allowed)
920 : : return mss_now;
921 : :
922 : : /* Note : tcp_tso_autosize() will eventually split this later */
923 : 1 : new_size_goal = sk->sk_gso_max_size - 1 - MAX_TCP_HEADER;
924 : 1 : new_size_goal = tcp_bound_to_half_wnd(tp, new_size_goal);
925 : :
926 : : /* We try hard to avoid divides here */
927 : 1 : size_goal = tp->gso_segs * mss_now;
928 : 1 : if (unlikely(new_size_goal < size_goal ||
929 : : new_size_goal >= size_goal + mss_now)) {
930 : 1 : tp->gso_segs = min_t(u16, new_size_goal / mss_now,
931 : : sk->sk_gso_max_segs);
932 : 1 : size_goal = tp->gso_segs * mss_now;
933 : : }
934 : :
935 : 1 : return max(size_goal, mss_now);
936 : : }
937 : :
938 : 1 : static int tcp_send_mss(struct sock *sk, int *size_goal, int flags)
939 : : {
940 : : int mss_now;
941 : :
942 : 1 : mss_now = tcp_current_mss(sk);
943 : 1 : *size_goal = tcp_xmit_size_goal(sk, mss_now, !(flags & MSG_OOB));
944 : :
945 : 1 : return mss_now;
946 : : }
947 : :
948 : : /* In some cases, both sendpage() and sendmsg() could have added
949 : : * an skb to the write queue, but failed adding payload on it.
950 : : * We need to remove it to consume less memory, but more
951 : : * importantly be able to generate EPOLLOUT for Edge Trigger epoll()
952 : : * users.
953 : : */
954 : 0 : static void tcp_remove_empty_skb(struct sock *sk, struct sk_buff *skb)
955 : : {
956 : 0 : if (skb && !skb->len) {
957 : : tcp_unlink_write_queue(skb, sk);
958 : 0 : if (tcp_write_queue_empty(sk))
959 : 0 : tcp_chrono_stop(sk, TCP_CHRONO_BUSY);
960 : 0 : sk_wmem_free_skb(sk, skb);
961 : : }
962 : 0 : }
963 : :
964 : 0 : ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset,
965 : : size_t size, int flags)
966 : : {
967 : : struct tcp_sock *tp = tcp_sk(sk);
968 : : int mss_now, size_goal;
969 : : int err;
970 : : ssize_t copied;
971 : 0 : long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
972 : :
973 : : if (IS_ENABLED(CONFIG_DEBUG_VM) &&
974 : : WARN_ONCE(PageSlab(page), "page must not be a Slab one"))
975 : : return -EINVAL;
976 : :
977 : : /* Wait for a connection to finish. One exception is TCP Fast Open
978 : : * (passive side) where data is allowed to be sent before a connection
979 : : * is fully established.
980 : : */
981 : 0 : if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
982 : : !tcp_passive_fastopen(sk)) {
983 : 0 : err = sk_stream_wait_connect(sk, &timeo);
984 : 0 : if (err != 0)
985 : : goto out_err;
986 : : }
987 : :
988 : 0 : sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
989 : :
990 : 0 : mss_now = tcp_send_mss(sk, &size_goal, flags);
991 : : copied = 0;
992 : :
993 : : err = -EPIPE;
994 : 0 : if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
995 : : goto out_err;
996 : :
997 : 0 : while (size > 0) {
998 : : struct sk_buff *skb = tcp_write_queue_tail(sk);
999 : : int copy, i;
1000 : : bool can_coalesce;
1001 : :
1002 : 0 : if (!skb || (copy = size_goal - skb->len) <= 0 ||
1003 : : !tcp_skb_can_collapse_to(skb)) {
1004 : : new_segment:
1005 : 0 : if (!sk_stream_memory_free(sk))
1006 : : goto wait_for_sndbuf;
1007 : :
1008 : 0 : skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation,
1009 : : tcp_rtx_and_write_queues_empty(sk));
1010 : 0 : if (!skb)
1011 : : goto wait_for_memory;
1012 : :
1013 : : #ifdef CONFIG_TLS_DEVICE
1014 : : skb->decrypted = !!(flags & MSG_SENDPAGE_DECRYPTED);
1015 : : #endif
1016 : 0 : skb_entail(sk, skb);
1017 : 0 : copy = size_goal;
1018 : : }
1019 : :
1020 : 0 : if (copy > size)
1021 : 0 : copy = size;
1022 : :
1023 : 0 : i = skb_shinfo(skb)->nr_frags;
1024 : 0 : can_coalesce = skb_can_coalesce(skb, i, page, offset);
1025 : 0 : if (!can_coalesce && i >= sysctl_max_skb_frags) {
1026 : : tcp_mark_push(tp, skb);
1027 : : goto new_segment;
1028 : : }
1029 : 0 : if (!sk_wmem_schedule(sk, copy))
1030 : : goto wait_for_memory;
1031 : :
1032 : 0 : if (can_coalesce) {
1033 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1034 : : } else {
1035 : 0 : get_page(page);
1036 : : skb_fill_page_desc(skb, i, page, offset, copy);
1037 : : }
1038 : :
1039 : 0 : if (!(flags & MSG_NO_SHARED_FRAGS))
1040 : 0 : skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG;
1041 : :
1042 : 0 : skb->len += copy;
1043 : 0 : skb->data_len += copy;
1044 : 0 : skb->truesize += copy;
1045 : : sk_wmem_queued_add(sk, copy);
1046 : : sk_mem_charge(sk, copy);
1047 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
1048 : 0 : WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
1049 : 0 : TCP_SKB_CB(skb)->end_seq += copy;
1050 : : tcp_skb_pcount_set(skb, 0);
1051 : :
1052 : 0 : if (!copied)
1053 : 0 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
1054 : :
1055 : 0 : copied += copy;
1056 : 0 : offset += copy;
1057 : 0 : size -= copy;
1058 : 0 : if (!size)
1059 : : goto out;
1060 : :
1061 : 0 : if (skb->len < size_goal || (flags & MSG_OOB))
1062 : 0 : continue;
1063 : :
1064 : 0 : if (forced_push(tp)) {
1065 : : tcp_mark_push(tp, skb);
1066 : 0 : __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
1067 : 0 : } else if (skb == tcp_send_head(sk))
1068 : 0 : tcp_push_one(sk, mss_now);
1069 : 0 : continue;
1070 : :
1071 : : wait_for_sndbuf:
1072 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1073 : : wait_for_memory:
1074 : 0 : tcp_push(sk, flags & ~MSG_MORE, mss_now,
1075 : : TCP_NAGLE_PUSH, size_goal);
1076 : :
1077 : 0 : err = sk_stream_wait_memory(sk, &timeo);
1078 : 0 : if (err != 0)
1079 : : goto do_error;
1080 : :
1081 : 0 : mss_now = tcp_send_mss(sk, &size_goal, flags);
1082 : : }
1083 : :
1084 : : out:
1085 : 0 : if (copied) {
1086 : 0 : tcp_tx_timestamp(sk, sk->sk_tsflags);
1087 : 0 : if (!(flags & MSG_SENDPAGE_NOTLAST))
1088 : 0 : tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
1089 : : }
1090 : 0 : return copied;
1091 : :
1092 : : do_error:
1093 : 0 : tcp_remove_empty_skb(sk, tcp_write_queue_tail(sk));
1094 : 0 : if (copied)
1095 : : goto out;
1096 : : out_err:
1097 : : /* make sure we wake any epoll edge trigger waiter */
1098 : 0 : if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
1099 : 0 : sk->sk_write_space(sk);
1100 : 0 : tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
1101 : : }
1102 : 0 : return sk_stream_error(sk, flags, err);
1103 : : }
1104 : : EXPORT_SYMBOL_GPL(do_tcp_sendpages);
1105 : :
1106 : 0 : int tcp_sendpage_locked(struct sock *sk, struct page *page, int offset,
1107 : : size_t size, int flags)
1108 : : {
1109 : 0 : if (!(sk->sk_route_caps & NETIF_F_SG))
1110 : 0 : return sock_no_sendpage_locked(sk, page, offset, size, flags);
1111 : :
1112 : 0 : tcp_rate_check_app_limited(sk); /* is sending application-limited? */
1113 : :
1114 : 0 : return do_tcp_sendpages(sk, page, offset, size, flags);
1115 : : }
1116 : : EXPORT_SYMBOL_GPL(tcp_sendpage_locked);
1117 : :
1118 : 0 : int tcp_sendpage(struct sock *sk, struct page *page, int offset,
1119 : : size_t size, int flags)
1120 : : {
1121 : : int ret;
1122 : :
1123 : : lock_sock(sk);
1124 : 0 : ret = tcp_sendpage_locked(sk, page, offset, size, flags);
1125 : 0 : release_sock(sk);
1126 : :
1127 : 0 : return ret;
1128 : : }
1129 : : EXPORT_SYMBOL(tcp_sendpage);
1130 : :
1131 : 1 : void tcp_free_fastopen_req(struct tcp_sock *tp)
1132 : : {
1133 : 1 : if (tp->fastopen_req) {
1134 : 0 : kfree(tp->fastopen_req);
1135 : 0 : tp->fastopen_req = NULL;
1136 : : }
1137 : 1 : }
1138 : :
1139 : 0 : static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg,
1140 : : int *copied, size_t size,
1141 : : struct ubuf_info *uarg)
1142 : : {
1143 : : struct tcp_sock *tp = tcp_sk(sk);
1144 : : struct inet_sock *inet = inet_sk(sk);
1145 : 0 : struct sockaddr *uaddr = msg->msg_name;
1146 : : int err, flags;
1147 : :
1148 : 0 : if (!(sock_net(sk)->ipv4.sysctl_tcp_fastopen & TFO_CLIENT_ENABLE) ||
1149 : 0 : (uaddr && msg->msg_namelen >= sizeof(uaddr->sa_family) &&
1150 : 0 : uaddr->sa_family == AF_UNSPEC))
1151 : : return -EOPNOTSUPP;
1152 : 0 : if (tp->fastopen_req)
1153 : : return -EALREADY; /* Another Fast Open is in progress */
1154 : :
1155 : 0 : tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request),
1156 : : sk->sk_allocation);
1157 : 0 : if (unlikely(!tp->fastopen_req))
1158 : : return -ENOBUFS;
1159 : 0 : tp->fastopen_req->data = msg;
1160 : 0 : tp->fastopen_req->size = size;
1161 : 0 : tp->fastopen_req->uarg = uarg;
1162 : :
1163 : 0 : if (inet->defer_connect) {
1164 : 0 : err = tcp_connect(sk);
1165 : : /* Same failure procedure as in tcp_v4/6_connect */
1166 : 0 : if (err) {
1167 : 0 : tcp_set_state(sk, TCP_CLOSE);
1168 : 0 : inet->inet_dport = 0;
1169 : 0 : sk->sk_route_caps = 0;
1170 : : }
1171 : : }
1172 : 0 : flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0;
1173 : 0 : err = __inet_stream_connect(sk->sk_socket, uaddr,
1174 : : msg->msg_namelen, flags, 1);
1175 : : /* fastopen_req could already be freed in __inet_stream_connect
1176 : : * if the connection times out or gets rst
1177 : : */
1178 : 0 : if (tp->fastopen_req) {
1179 : 0 : *copied = tp->fastopen_req->copied;
1180 : : tcp_free_fastopen_req(tp);
1181 : 0 : inet->defer_connect = 0;
1182 : : }
1183 : 0 : return err;
1184 : : }
1185 : :
1186 : 1 : int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
1187 : : {
1188 : : struct tcp_sock *tp = tcp_sk(sk);
1189 : : struct ubuf_info *uarg = NULL;
1190 : : struct sk_buff *skb;
1191 : : struct sockcm_cookie sockc;
1192 : : int flags, err, copied = 0;
1193 : 1 : int mss_now = 0, size_goal, copied_syn = 0;
1194 : : int process_backlog = 0;
1195 : : bool zc = false;
1196 : : long timeo;
1197 : :
1198 : 1 : flags = msg->msg_flags;
1199 : :
1200 : 1 : if (flags & MSG_ZEROCOPY && size && sock_flag(sk, SOCK_ZEROCOPY)) {
1201 : : skb = tcp_write_queue_tail(sk);
1202 : 0 : uarg = sock_zerocopy_realloc(sk, size, skb_zcopy(skb));
1203 : 0 : if (!uarg) {
1204 : : err = -ENOBUFS;
1205 : : goto out_err;
1206 : : }
1207 : :
1208 : 0 : zc = sk->sk_route_caps & NETIF_F_SG;
1209 : 0 : if (!zc)
1210 : 0 : uarg->zerocopy = 0;
1211 : : }
1212 : :
1213 : 1 : if (unlikely(flags & MSG_FASTOPEN || inet_sk(sk)->defer_connect) &&
1214 : 0 : !tp->repair) {
1215 : 0 : err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size, uarg);
1216 : 0 : if (err == -EINPROGRESS && copied_syn > 0)
1217 : : goto out;
1218 : 0 : else if (err)
1219 : : goto out_err;
1220 : : }
1221 : :
1222 : 1 : timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
1223 : :
1224 : 1 : tcp_rate_check_app_limited(sk); /* is sending application-limited? */
1225 : :
1226 : : /* Wait for a connection to finish. One exception is TCP Fast Open
1227 : : * (passive side) where data is allowed to be sent before a connection
1228 : : * is fully established.
1229 : : */
1230 : 1 : if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
1231 : : !tcp_passive_fastopen(sk)) {
1232 : 0 : err = sk_stream_wait_connect(sk, &timeo);
1233 : 0 : if (err != 0)
1234 : : goto do_error;
1235 : : }
1236 : :
1237 : 1 : if (unlikely(tp->repair)) {
1238 : 0 : if (tp->repair_queue == TCP_RECV_QUEUE) {
1239 : 0 : copied = tcp_send_rcvq(sk, msg, size);
1240 : 0 : goto out_nopush;
1241 : : }
1242 : :
1243 : : err = -EINVAL;
1244 : 0 : if (tp->repair_queue == TCP_NO_QUEUE)
1245 : : goto out_err;
1246 : :
1247 : : /* 'common' sending to sendq */
1248 : : }
1249 : :
1250 : : sockcm_init(&sockc, sk);
1251 : 1 : if (msg->msg_controllen) {
1252 : 0 : err = sock_cmsg_send(sk, msg, &sockc);
1253 : 0 : if (unlikely(err)) {
1254 : : err = -EINVAL;
1255 : : goto out_err;
1256 : : }
1257 : : }
1258 : :
1259 : : /* This should be in poll */
1260 : 1 : sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1261 : :
1262 : : /* Ok commence sending. */
1263 : : copied = 0;
1264 : :
1265 : : restart:
1266 : 1 : mss_now = tcp_send_mss(sk, &size_goal, flags);
1267 : :
1268 : : err = -EPIPE;
1269 : 1 : if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
1270 : : goto do_error;
1271 : :
1272 : 1 : while (msg_data_left(msg)) {
1273 : : int copy = 0;
1274 : :
1275 : : skb = tcp_write_queue_tail(sk);
1276 : 1 : if (skb)
1277 : 1 : copy = size_goal - skb->len;
1278 : :
1279 : 1 : if (copy <= 0 || !tcp_skb_can_collapse_to(skb)) {
1280 : : bool first_skb;
1281 : :
1282 : : new_segment:
1283 : 1 : if (!sk_stream_memory_free(sk))
1284 : : goto wait_for_sndbuf;
1285 : :
1286 : 1 : if (unlikely(process_backlog >= 16)) {
1287 : : process_backlog = 0;
1288 : 0 : if (sk_flush_backlog(sk))
1289 : : goto restart;
1290 : : }
1291 : : first_skb = tcp_rtx_and_write_queues_empty(sk);
1292 : 1 : skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation,
1293 : : first_skb);
1294 : 1 : if (!skb)
1295 : : goto wait_for_memory;
1296 : :
1297 : 1 : process_backlog++;
1298 : 1 : skb->ip_summed = CHECKSUM_PARTIAL;
1299 : :
1300 : 1 : skb_entail(sk, skb);
1301 : 1 : copy = size_goal;
1302 : :
1303 : : /* All packets are restored as if they have
1304 : : * already been sent. skb_mstamp_ns isn't set to
1305 : : * avoid wrong rtt estimation.
1306 : : */
1307 : 1 : if (tp->repair)
1308 : 0 : TCP_SKB_CB(skb)->sacked |= TCPCB_REPAIRED;
1309 : : }
1310 : :
1311 : : /* Try to append data to the end of skb. */
1312 : 1 : if (copy > msg_data_left(msg))
1313 : 1 : copy = msg_data_left(msg);
1314 : :
1315 : : /* Where to copy to? */
1316 : 1 : if (skb_availroom(skb) > 0 && !zc) {
1317 : : /* We have some space in skb head. Superb! */
1318 : 0 : copy = min_t(int, copy, skb_availroom(skb));
1319 : 0 : err = skb_add_data_nocache(sk, skb, &msg->msg_iter, copy);
1320 : 0 : if (err)
1321 : : goto do_fault;
1322 : 1 : } else if (!zc) {
1323 : : bool merge = true;
1324 : 1 : int i = skb_shinfo(skb)->nr_frags;
1325 : : struct page_frag *pfrag = sk_page_frag(sk);
1326 : :
1327 : 1 : if (!sk_page_frag_refill(sk, pfrag))
1328 : : goto wait_for_memory;
1329 : :
1330 : 1 : if (!skb_can_coalesce(skb, i, pfrag->page,
1331 : 1 : pfrag->offset)) {
1332 : 1 : if (i >= sysctl_max_skb_frags) {
1333 : : tcp_mark_push(tp, skb);
1334 : : goto new_segment;
1335 : : }
1336 : : merge = false;
1337 : : }
1338 : :
1339 : 1 : copy = min_t(int, copy, pfrag->size - pfrag->offset);
1340 : :
1341 : 1 : if (!sk_wmem_schedule(sk, copy))
1342 : : goto wait_for_memory;
1343 : :
1344 : 1 : err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
1345 : : pfrag->page,
1346 : 1 : pfrag->offset,
1347 : : copy);
1348 : 1 : if (err)
1349 : : goto do_error;
1350 : :
1351 : : /* Update the skb. */
1352 : 1 : if (merge) {
1353 : 1 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1354 : : } else {
1355 : 1 : skb_fill_page_desc(skb, i, pfrag->page,
1356 : 1 : pfrag->offset, copy);
1357 : 1 : page_ref_inc(pfrag->page);
1358 : : }
1359 : 1 : pfrag->offset += copy;
1360 : : } else {
1361 : 0 : err = skb_zerocopy_iter_stream(sk, skb, msg, copy, uarg);
1362 : 0 : if (err == -EMSGSIZE || err == -EEXIST) {
1363 : : tcp_mark_push(tp, skb);
1364 : : goto new_segment;
1365 : : }
1366 : 0 : if (err < 0)
1367 : : goto do_error;
1368 : : copy = err;
1369 : : }
1370 : :
1371 : 1 : if (!copied)
1372 : 1 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
1373 : :
1374 : 1 : WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
1375 : 1 : TCP_SKB_CB(skb)->end_seq += copy;
1376 : : tcp_skb_pcount_set(skb, 0);
1377 : :
1378 : 1 : copied += copy;
1379 : 1 : if (!msg_data_left(msg)) {
1380 : 1 : if (unlikely(flags & MSG_EOR))
1381 : 0 : TCP_SKB_CB(skb)->eor = 1;
1382 : : goto out;
1383 : : }
1384 : :
1385 : 0 : if (skb->len < size_goal || (flags & MSG_OOB) || unlikely(tp->repair))
1386 : 0 : continue;
1387 : :
1388 : 0 : if (forced_push(tp)) {
1389 : : tcp_mark_push(tp, skb);
1390 : 0 : __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
1391 : 0 : } else if (skb == tcp_send_head(sk))
1392 : 0 : tcp_push_one(sk, mss_now);
1393 : 0 : continue;
1394 : :
1395 : : wait_for_sndbuf:
1396 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1397 : : wait_for_memory:
1398 : 0 : if (copied)
1399 : 0 : tcp_push(sk, flags & ~MSG_MORE, mss_now,
1400 : : TCP_NAGLE_PUSH, size_goal);
1401 : :
1402 : 0 : err = sk_stream_wait_memory(sk, &timeo);
1403 : 0 : if (err != 0)
1404 : : goto do_error;
1405 : :
1406 : 0 : mss_now = tcp_send_mss(sk, &size_goal, flags);
1407 : : }
1408 : :
1409 : : out:
1410 : 1 : if (copied) {
1411 : 1 : tcp_tx_timestamp(sk, sockc.tsflags);
1412 : 1 : tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
1413 : : }
1414 : : out_nopush:
1415 : 1 : sock_zerocopy_put(uarg);
1416 : 1 : return copied + copied_syn;
1417 : :
1418 : : do_error:
1419 : : skb = tcp_write_queue_tail(sk);
1420 : : do_fault:
1421 : 0 : tcp_remove_empty_skb(sk, skb);
1422 : :
1423 : 0 : if (copied + copied_syn)
1424 : : goto out;
1425 : : out_err:
1426 : 0 : sock_zerocopy_put_abort(uarg, true);
1427 : 0 : err = sk_stream_error(sk, flags, err);
1428 : : /* make sure we wake any epoll edge trigger waiter */
1429 : 0 : if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
1430 : 0 : sk->sk_write_space(sk);
1431 : 0 : tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
1432 : : }
1433 : 0 : return err;
1434 : : }
1435 : : EXPORT_SYMBOL_GPL(tcp_sendmsg_locked);
1436 : :
1437 : 1 : int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
1438 : : {
1439 : : int ret;
1440 : :
1441 : : lock_sock(sk);
1442 : 1 : ret = tcp_sendmsg_locked(sk, msg, size);
1443 : 1 : release_sock(sk);
1444 : :
1445 : 1 : return ret;
1446 : : }
1447 : : EXPORT_SYMBOL(tcp_sendmsg);
1448 : :
1449 : : /*
1450 : : * Handle reading urgent data. BSD has very simple semantics for
1451 : : * this, no blocking and very strange errors 8)
1452 : : */
1453 : :
1454 : 0 : static int tcp_recv_urg(struct sock *sk, struct msghdr *msg, int len, int flags)
1455 : : {
1456 : : struct tcp_sock *tp = tcp_sk(sk);
1457 : :
1458 : : /* No URG data to read. */
1459 : 0 : if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
1460 : : tp->urg_data == TCP_URG_READ)
1461 : : return -EINVAL; /* Yes this is right ! */
1462 : :
1463 : 0 : if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE))
1464 : : return -ENOTCONN;
1465 : :
1466 : 0 : if (tp->urg_data & TCP_URG_VALID) {
1467 : : int err = 0;
1468 : 0 : char c = tp->urg_data;
1469 : :
1470 : 0 : if (!(flags & MSG_PEEK))
1471 : 0 : tp->urg_data = TCP_URG_READ;
1472 : :
1473 : : /* Read urgent data. */
1474 : 0 : msg->msg_flags |= MSG_OOB;
1475 : :
1476 : 0 : if (len > 0) {
1477 : 0 : if (!(flags & MSG_TRUNC))
1478 : 0 : err = memcpy_to_msg(msg, &c, 1);
1479 : : len = 1;
1480 : : } else
1481 : 0 : msg->msg_flags |= MSG_TRUNC;
1482 : :
1483 : 0 : return err ? -EFAULT : len;
1484 : : }
1485 : :
1486 : 0 : if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN))
1487 : : return 0;
1488 : :
1489 : : /* Fixed the recv(..., MSG_OOB) behaviour. BSD docs and
1490 : : * the available implementations agree in this case:
1491 : : * this call should never block, independent of the
1492 : : * blocking state of the socket.
1493 : : * Mike <pall@rz.uni-karlsruhe.de>
1494 : : */
1495 : 0 : return -EAGAIN;
1496 : : }
1497 : :
1498 : 0 : static int tcp_peek_sndq(struct sock *sk, struct msghdr *msg, int len)
1499 : : {
1500 : : struct sk_buff *skb;
1501 : : int copied = 0, err = 0;
1502 : :
1503 : : /* XXX -- need to support SO_PEEK_OFF */
1504 : :
1505 : 0 : skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
1506 : 0 : err = skb_copy_datagram_msg(skb, 0, msg, skb->len);
1507 : 0 : if (err)
1508 : 0 : return err;
1509 : 0 : copied += skb->len;
1510 : : }
1511 : :
1512 : 0 : skb_queue_walk(&sk->sk_write_queue, skb) {
1513 : 0 : err = skb_copy_datagram_msg(skb, 0, msg, skb->len);
1514 : 0 : if (err)
1515 : : break;
1516 : :
1517 : 0 : copied += skb->len;
1518 : : }
1519 : :
1520 : 0 : return err ?: copied;
1521 : : }
1522 : :
1523 : : /* Clean up the receive buffer for full frames taken by the user,
1524 : : * then send an ACK if necessary. COPIED is the number of bytes
1525 : : * tcp_recvmsg has given to the user so far, it speeds up the
1526 : : * calculation of whether or not we must ACK for the sake of
1527 : : * a window update.
1528 : : */
1529 : 1 : static void tcp_cleanup_rbuf(struct sock *sk, int copied)
1530 : : {
1531 : : struct tcp_sock *tp = tcp_sk(sk);
1532 : : bool time_to_ack = false;
1533 : :
1534 : 1 : struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
1535 : :
1536 : 1 : WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq),
1537 : : "cleanup rbuf bug: copied %X seq %X rcvnxt %X\n",
1538 : : tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt);
1539 : :
1540 : 1 : if (inet_csk_ack_scheduled(sk)) {
1541 : : const struct inet_connection_sock *icsk = inet_csk(sk);
1542 : : /* Delayed ACKs frequently hit locked sockets during bulk
1543 : : * receive. */
1544 : 1 : if (icsk->icsk_ack.blocked ||
1545 : : /* Once-per-two-segments ACK was not sent by tcp_input.c */
1546 : 1 : tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
1547 : : /*
1548 : : * If this read emptied read buffer, we send ACK, if
1549 : : * connection is not bidirectional, user drained
1550 : : * receive buffer and there was a small segment
1551 : : * in queue.
1552 : : */
1553 : 1 : (copied > 0 &&
1554 : 1 : ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED2) ||
1555 : 1 : ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED) &&
1556 : 1 : !inet_csk_in_pingpong_mode(sk))) &&
1557 : 1 : !atomic_read(&sk->sk_rmem_alloc)))
1558 : : time_to_ack = true;
1559 : : }
1560 : :
1561 : : /* We send an ACK if we can now advertise a non-zero window
1562 : : * which has been raised "significantly".
1563 : : *
1564 : : * Even if window raised up to infinity, do not send window open ACK
1565 : : * in states, where we will not receive more. It is useless.
1566 : : */
1567 : 1 : if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1568 : : __u32 rcv_window_now = tcp_receive_window(tp);
1569 : :
1570 : : /* Optimize, __tcp_select_window() is not cheap. */
1571 : 1 : if (2*rcv_window_now <= tp->window_clamp) {
1572 : 1 : __u32 new_window = __tcp_select_window(sk);
1573 : :
1574 : : /* Send ACK now, if this read freed lots of space
1575 : : * in our buffer. Certainly, new_window is new window.
1576 : : * We can advertise it now, if it is not less than current one.
1577 : : * "Lots" means "at least twice" here.
1578 : : */
1579 : 1 : if (new_window && new_window >= 2 * rcv_window_now)
1580 : : time_to_ack = true;
1581 : : }
1582 : : }
1583 : 1 : if (time_to_ack)
1584 : 1 : tcp_send_ack(sk);
1585 : 1 : }
1586 : :
1587 : 0 : static struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
1588 : : {
1589 : : struct sk_buff *skb;
1590 : : u32 offset;
1591 : :
1592 : 0 : while ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) {
1593 : 0 : offset = seq - TCP_SKB_CB(skb)->seq;
1594 : 0 : if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
1595 : 0 : pr_err_once("%s: found a SYN, please report !\n", __func__);
1596 : 0 : offset--;
1597 : : }
1598 : 0 : if (offset < skb->len || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)) {
1599 : 0 : *off = offset;
1600 : 0 : return skb;
1601 : : }
1602 : : /* This looks weird, but this can happen if TCP collapsing
1603 : : * splitted a fat GRO packet, while we released socket lock
1604 : : * in skb_splice_bits()
1605 : : */
1606 : 0 : sk_eat_skb(sk, skb);
1607 : : }
1608 : : return NULL;
1609 : : }
1610 : :
1611 : : /*
1612 : : * This routine provides an alternative to tcp_recvmsg() for routines
1613 : : * that would like to handle copying from skbuffs directly in 'sendfile'
1614 : : * fashion.
1615 : : * Note:
1616 : : * - It is assumed that the socket was locked by the caller.
1617 : : * - The routine does not block.
1618 : : * - At present, there is no support for reading OOB data
1619 : : * or for 'peeking' the socket using this routine
1620 : : * (although both would be easy to implement).
1621 : : */
1622 : 0 : int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
1623 : : sk_read_actor_t recv_actor)
1624 : : {
1625 : : struct sk_buff *skb;
1626 : : struct tcp_sock *tp = tcp_sk(sk);
1627 : 0 : u32 seq = tp->copied_seq;
1628 : : u32 offset;
1629 : : int copied = 0;
1630 : :
1631 : 0 : if (sk->sk_state == TCP_LISTEN)
1632 : : return -ENOTCONN;
1633 : 0 : while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
1634 : 0 : if (offset < skb->len) {
1635 : : int used;
1636 : : size_t len;
1637 : :
1638 : 0 : len = skb->len - offset;
1639 : : /* Stop reading if we hit a patch of urgent data */
1640 : 0 : if (tp->urg_data) {
1641 : 0 : u32 urg_offset = tp->urg_seq - seq;
1642 : 0 : if (urg_offset < len)
1643 : : len = urg_offset;
1644 : 0 : if (!len)
1645 : : break;
1646 : : }
1647 : 0 : used = recv_actor(desc, skb, offset, len);
1648 : 0 : if (used <= 0) {
1649 : 0 : if (!copied)
1650 : 0 : copied = used;
1651 : : break;
1652 : 0 : } else if (used <= len) {
1653 : 0 : seq += used;
1654 : 0 : copied += used;
1655 : 0 : offset += used;
1656 : : }
1657 : : /* If recv_actor drops the lock (e.g. TCP splice
1658 : : * receive) the skb pointer might be invalid when
1659 : : * getting here: tcp_collapse might have deleted it
1660 : : * while aggregating skbs from the socket queue.
1661 : : */
1662 : 0 : skb = tcp_recv_skb(sk, seq - 1, &offset);
1663 : 0 : if (!skb)
1664 : : break;
1665 : : /* TCP coalescing might have appended data to the skb.
1666 : : * Try to splice more frags
1667 : : */
1668 : 0 : if (offset + 1 != skb->len)
1669 : 0 : continue;
1670 : : }
1671 : 0 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) {
1672 : 0 : sk_eat_skb(sk, skb);
1673 : 0 : ++seq;
1674 : 0 : break;
1675 : : }
1676 : 0 : sk_eat_skb(sk, skb);
1677 : 0 : if (!desc->count)
1678 : : break;
1679 : : WRITE_ONCE(tp->copied_seq, seq);
1680 : : }
1681 : : WRITE_ONCE(tp->copied_seq, seq);
1682 : :
1683 : 0 : tcp_rcv_space_adjust(sk);
1684 : :
1685 : : /* Clean up data we have read: This will do ACK frames. */
1686 : 0 : if (copied > 0) {
1687 : 0 : tcp_recv_skb(sk, seq, &offset);
1688 : 0 : tcp_cleanup_rbuf(sk, copied);
1689 : : }
1690 : 0 : return copied;
1691 : : }
1692 : : EXPORT_SYMBOL(tcp_read_sock);
1693 : :
1694 : 0 : int tcp_peek_len(struct socket *sock)
1695 : : {
1696 : 0 : return tcp_inq(sock->sk);
1697 : : }
1698 : : EXPORT_SYMBOL(tcp_peek_len);
1699 : :
1700 : : /* Make sure sk_rcvbuf is big enough to satisfy SO_RCVLOWAT hint */
1701 : 0 : int tcp_set_rcvlowat(struct sock *sk, int val)
1702 : : {
1703 : : int cap;
1704 : :
1705 : 0 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1706 : 0 : cap = sk->sk_rcvbuf >> 1;
1707 : : else
1708 : 0 : cap = sock_net(sk)->ipv4.sysctl_tcp_rmem[2] >> 1;
1709 : 0 : val = min(val, cap);
1710 : 0 : WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
1711 : :
1712 : : /* Check if we need to signal EPOLLIN right now */
1713 : 0 : tcp_data_ready(sk);
1714 : :
1715 : 0 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
1716 : : return 0;
1717 : :
1718 : 0 : val <<= 1;
1719 : 0 : if (val > sk->sk_rcvbuf) {
1720 : : WRITE_ONCE(sk->sk_rcvbuf, val);
1721 : 0 : tcp_sk(sk)->window_clamp = tcp_win_from_space(sk, val);
1722 : : }
1723 : : return 0;
1724 : : }
1725 : : EXPORT_SYMBOL(tcp_set_rcvlowat);
1726 : :
1727 : : #ifdef CONFIG_MMU
1728 : : static const struct vm_operations_struct tcp_vm_ops = {
1729 : : };
1730 : :
1731 : 0 : int tcp_mmap(struct file *file, struct socket *sock,
1732 : : struct vm_area_struct *vma)
1733 : : {
1734 : 0 : if (vma->vm_flags & (VM_WRITE | VM_EXEC))
1735 : : return -EPERM;
1736 : 0 : vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC);
1737 : :
1738 : : /* Instruct vm_insert_page() to not down_read(mmap_sem) */
1739 : 0 : vma->vm_flags |= VM_MIXEDMAP;
1740 : :
1741 : 0 : vma->vm_ops = &tcp_vm_ops;
1742 : 0 : return 0;
1743 : : }
1744 : : EXPORT_SYMBOL(tcp_mmap);
1745 : :
1746 : 0 : static int tcp_zerocopy_receive(struct sock *sk,
1747 : : struct tcp_zerocopy_receive *zc)
1748 : : {
1749 : 0 : unsigned long address = (unsigned long)zc->address;
1750 : : const skb_frag_t *frags = NULL;
1751 : : u32 length = 0, seq, offset;
1752 : : struct vm_area_struct *vma;
1753 : : struct sk_buff *skb = NULL;
1754 : : struct tcp_sock *tp;
1755 : : int inq;
1756 : : int ret;
1757 : :
1758 : 0 : if (address & (PAGE_SIZE - 1) || address != zc->address)
1759 : : return -EINVAL;
1760 : :
1761 : 0 : if (sk->sk_state == TCP_LISTEN)
1762 : : return -ENOTCONN;
1763 : :
1764 : 0 : sock_rps_record_flow(sk);
1765 : :
1766 : 0 : down_read(¤t->mm->mmap_sem);
1767 : :
1768 : 0 : vma = find_vma(current->mm, address);
1769 : 0 : if (!vma || vma->vm_start > address || vma->vm_ops != &tcp_vm_ops) {
1770 : 0 : up_read(¤t->mm->mmap_sem);
1771 : 0 : return -EINVAL;
1772 : : }
1773 : 0 : zc->length = min_t(unsigned long, zc->length, vma->vm_end - address);
1774 : :
1775 : : tp = tcp_sk(sk);
1776 : 0 : seq = tp->copied_seq;
1777 : 0 : inq = tcp_inq(sk);
1778 : 0 : zc->length = min_t(u32, zc->length, inq);
1779 : 0 : zc->length &= ~(PAGE_SIZE - 1);
1780 : 0 : if (zc->length) {
1781 : 0 : zap_page_range(vma, address, zc->length);
1782 : 0 : zc->recv_skip_hint = 0;
1783 : : } else {
1784 : 0 : zc->recv_skip_hint = inq;
1785 : : }
1786 : : ret = 0;
1787 : 0 : while (length + PAGE_SIZE <= zc->length) {
1788 : 0 : if (zc->recv_skip_hint < PAGE_SIZE) {
1789 : 0 : if (skb) {
1790 : 0 : skb = skb->next;
1791 : 0 : offset = seq - TCP_SKB_CB(skb)->seq;
1792 : : } else {
1793 : 0 : skb = tcp_recv_skb(sk, seq, &offset);
1794 : : }
1795 : :
1796 : 0 : zc->recv_skip_hint = skb->len - offset;
1797 : 0 : offset -= skb_headlen(skb);
1798 : 0 : if ((int)offset < 0 || skb_has_frag_list(skb))
1799 : : break;
1800 : 0 : frags = skb_shinfo(skb)->frags;
1801 : 0 : while (offset) {
1802 : 0 : if (skb_frag_size(frags) > offset)
1803 : : goto out;
1804 : 0 : offset -= skb_frag_size(frags);
1805 : 0 : frags++;
1806 : : }
1807 : : }
1808 : 0 : if (skb_frag_size(frags) != PAGE_SIZE || skb_frag_off(frags)) {
1809 : 0 : int remaining = zc->recv_skip_hint;
1810 : :
1811 : 0 : while (remaining && (skb_frag_size(frags) != PAGE_SIZE ||
1812 : : skb_frag_off(frags))) {
1813 : 0 : remaining -= skb_frag_size(frags);
1814 : 0 : frags++;
1815 : : }
1816 : 0 : zc->recv_skip_hint -= remaining;
1817 : 0 : break;
1818 : : }
1819 : 0 : ret = vm_insert_page(vma, address + length,
1820 : : skb_frag_page(frags));
1821 : 0 : if (ret)
1822 : : break;
1823 : : length += PAGE_SIZE;
1824 : 0 : seq += PAGE_SIZE;
1825 : 0 : zc->recv_skip_hint -= PAGE_SIZE;
1826 : 0 : frags++;
1827 : : }
1828 : : out:
1829 : 0 : up_read(¤t->mm->mmap_sem);
1830 : 0 : if (length) {
1831 : 0 : WRITE_ONCE(tp->copied_seq, seq);
1832 : 0 : tcp_rcv_space_adjust(sk);
1833 : :
1834 : : /* Clean up data we have read: This will do ACK frames. */
1835 : 0 : tcp_recv_skb(sk, seq, &offset);
1836 : 0 : tcp_cleanup_rbuf(sk, length);
1837 : : ret = 0;
1838 : 0 : if (length == zc->length)
1839 : 0 : zc->recv_skip_hint = 0;
1840 : : } else {
1841 : 0 : if (!zc->recv_skip_hint && sock_flag(sk, SOCK_DONE))
1842 : : ret = -EIO;
1843 : : }
1844 : 0 : zc->length = length;
1845 : 0 : return ret;
1846 : : }
1847 : : #endif
1848 : :
1849 : 0 : static void tcp_update_recv_tstamps(struct sk_buff *skb,
1850 : : struct scm_timestamping_internal *tss)
1851 : : {
1852 : 0 : if (skb->tstamp)
1853 : 0 : tss->ts[0] = ktime_to_timespec64(skb->tstamp);
1854 : : else
1855 : 0 : tss->ts[0] = (struct timespec64) {0};
1856 : :
1857 : 0 : if (skb_hwtstamps(skb)->hwtstamp)
1858 : 0 : tss->ts[2] = ktime_to_timespec64(skb_hwtstamps(skb)->hwtstamp);
1859 : : else
1860 : 0 : tss->ts[2] = (struct timespec64) {0};
1861 : 0 : }
1862 : :
1863 : : /* Similar to __sock_recv_timestamp, but does not require an skb */
1864 : 0 : static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
1865 : : struct scm_timestamping_internal *tss)
1866 : : {
1867 : 0 : int new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
1868 : : bool has_timestamping = false;
1869 : :
1870 : 0 : if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) {
1871 : 0 : if (sock_flag(sk, SOCK_RCVTSTAMP)) {
1872 : 0 : if (sock_flag(sk, SOCK_RCVTSTAMPNS)) {
1873 : 0 : if (new_tstamp) {
1874 : 0 : struct __kernel_timespec kts = {tss->ts[0].tv_sec, tss->ts[0].tv_nsec};
1875 : :
1876 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
1877 : : sizeof(kts), &kts);
1878 : : } else {
1879 : : struct timespec ts_old = timespec64_to_timespec(tss->ts[0]);
1880 : :
1881 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
1882 : : sizeof(ts_old), &ts_old);
1883 : : }
1884 : : } else {
1885 : 0 : if (new_tstamp) {
1886 : : struct __kernel_sock_timeval stv;
1887 : :
1888 : 0 : stv.tv_sec = tss->ts[0].tv_sec;
1889 : 0 : stv.tv_usec = tss->ts[0].tv_nsec / 1000;
1890 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
1891 : : sizeof(stv), &stv);
1892 : : } else {
1893 : : struct __kernel_old_timeval tv;
1894 : :
1895 : 0 : tv.tv_sec = tss->ts[0].tv_sec;
1896 : 0 : tv.tv_usec = tss->ts[0].tv_nsec / 1000;
1897 : 0 : put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
1898 : : sizeof(tv), &tv);
1899 : : }
1900 : : }
1901 : : }
1902 : :
1903 : 0 : if (sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE)
1904 : : has_timestamping = true;
1905 : : else
1906 : 0 : tss->ts[0] = (struct timespec64) {0};
1907 : : }
1908 : :
1909 : 0 : if (tss->ts[2].tv_sec || tss->ts[2].tv_nsec) {
1910 : 0 : if (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE)
1911 : : has_timestamping = true;
1912 : : else
1913 : 0 : tss->ts[2] = (struct timespec64) {0};
1914 : : }
1915 : :
1916 : 0 : if (has_timestamping) {
1917 : 0 : tss->ts[1] = (struct timespec64) {0};
1918 : 0 : if (sock_flag(sk, SOCK_TSTAMP_NEW))
1919 : 0 : put_cmsg_scm_timestamping64(msg, tss);
1920 : : else
1921 : 0 : put_cmsg_scm_timestamping(msg, tss);
1922 : : }
1923 : 0 : }
1924 : :
1925 : 0 : static int tcp_inq_hint(struct sock *sk)
1926 : : {
1927 : : const struct tcp_sock *tp = tcp_sk(sk);
1928 : : u32 copied_seq = READ_ONCE(tp->copied_seq);
1929 : : u32 rcv_nxt = READ_ONCE(tp->rcv_nxt);
1930 : : int inq;
1931 : :
1932 : 0 : inq = rcv_nxt - copied_seq;
1933 : 0 : if (unlikely(inq < 0 || copied_seq != READ_ONCE(tp->copied_seq))) {
1934 : : lock_sock(sk);
1935 : 0 : inq = tp->rcv_nxt - tp->copied_seq;
1936 : 0 : release_sock(sk);
1937 : : }
1938 : : /* After receiving a FIN, tell the user-space to continue reading
1939 : : * by returning a non-zero inq.
1940 : : */
1941 : 0 : if (inq == 0 && sock_flag(sk, SOCK_DONE))
1942 : : inq = 1;
1943 : 0 : return inq;
1944 : : }
1945 : :
1946 : : /*
1947 : : * This routine copies from a sock struct into the user buffer.
1948 : : *
1949 : : * Technical note: in 2.3 we work on _locked_ socket, so that
1950 : : * tricks with *seq access order and skb->users are not required.
1951 : : * Probably, code can be easily improved even more.
1952 : : */
1953 : :
1954 : 1 : int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
1955 : : int flags, int *addr_len)
1956 : : {
1957 : : struct tcp_sock *tp = tcp_sk(sk);
1958 : : int copied = 0;
1959 : : u32 peek_seq;
1960 : : u32 *seq;
1961 : : unsigned long used;
1962 : : int err, inq;
1963 : : int target; /* Read at least this many bytes */
1964 : : long timeo;
1965 : : struct sk_buff *skb, *last;
1966 : : u32 urg_hole = 0;
1967 : : struct scm_timestamping_internal tss;
1968 : : int cmsg_flags;
1969 : :
1970 : 1 : if (unlikely(flags & MSG_ERRQUEUE))
1971 : 0 : return inet_recv_error(sk, msg, len, addr_len);
1972 : :
1973 : 1 : if (sk_can_busy_loop(sk) && skb_queue_empty_lockless(&sk->sk_receive_queue) &&
1974 : 0 : (sk->sk_state == TCP_ESTABLISHED))
1975 : 0 : sk_busy_loop(sk, nonblock);
1976 : :
1977 : : lock_sock(sk);
1978 : :
1979 : : err = -ENOTCONN;
1980 : 1 : if (sk->sk_state == TCP_LISTEN)
1981 : : goto out;
1982 : :
1983 : 1 : cmsg_flags = tp->recvmsg_inq ? 1 : 0;
1984 : 1 : timeo = sock_rcvtimeo(sk, nonblock);
1985 : :
1986 : : /* Urgent data needs to be handled specially. */
1987 : 1 : if (flags & MSG_OOB)
1988 : : goto recv_urg;
1989 : :
1990 : 1 : if (unlikely(tp->repair)) {
1991 : : err = -EPERM;
1992 : 0 : if (!(flags & MSG_PEEK))
1993 : : goto out;
1994 : :
1995 : 0 : if (tp->repair_queue == TCP_SEND_QUEUE)
1996 : : goto recv_sndq;
1997 : :
1998 : : err = -EINVAL;
1999 : 0 : if (tp->repair_queue == TCP_NO_QUEUE)
2000 : : goto out;
2001 : :
2002 : : /* 'common' recv queue MSG_PEEK-ing */
2003 : : }
2004 : :
2005 : 1 : seq = &tp->copied_seq;
2006 : 1 : if (flags & MSG_PEEK) {
2007 : 1 : peek_seq = tp->copied_seq;
2008 : : seq = &peek_seq;
2009 : : }
2010 : :
2011 : 1 : target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
2012 : :
2013 : : do {
2014 : : u32 offset;
2015 : :
2016 : : /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
2017 : 1 : if (tp->urg_data && tp->urg_seq == *seq) {
2018 : 0 : if (copied)
2019 : : break;
2020 : 0 : if (signal_pending(current)) {
2021 : 0 : copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
2022 : 0 : break;
2023 : : }
2024 : : }
2025 : :
2026 : : /* Next get a buffer. */
2027 : :
2028 : 1 : last = skb_peek_tail(&sk->sk_receive_queue);
2029 : 1 : skb_queue_walk(&sk->sk_receive_queue, skb) {
2030 : : last = skb;
2031 : : /* Now that we have two receive queues this
2032 : : * shouldn't happen.
2033 : : */
2034 : 1 : if (WARN(before(*seq, TCP_SKB_CB(skb)->seq),
2035 : : "TCP recvmsg seq # bug: copied %X, seq %X, rcvnxt %X, fl %X\n",
2036 : : *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
2037 : : flags))
2038 : : break;
2039 : :
2040 : 1 : offset = *seq - TCP_SKB_CB(skb)->seq;
2041 : 1 : if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
2042 : 0 : pr_err_once("%s: found a SYN, please report !\n", __func__);
2043 : 0 : offset--;
2044 : : }
2045 : 1 : if (offset < skb->len)
2046 : : goto found_ok_skb;
2047 : 0 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
2048 : : goto found_fin_ok;
2049 : 0 : WARN(!(flags & MSG_PEEK),
2050 : : "TCP recvmsg seq # bug 2: copied %X, seq %X, rcvnxt %X, fl %X\n",
2051 : : *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags);
2052 : : }
2053 : :
2054 : : /* Well, if we have backlog, try to process it now yet. */
2055 : :
2056 : 1 : if (copied >= target && !sk->sk_backlog.tail)
2057 : : break;
2058 : :
2059 : 1 : if (copied) {
2060 : 1 : if (sk->sk_err ||
2061 : 1 : sk->sk_state == TCP_CLOSE ||
2062 : 1 : (sk->sk_shutdown & RCV_SHUTDOWN) ||
2063 : 1 : !timeo ||
2064 : 0 : signal_pending(current))
2065 : : break;
2066 : : } else {
2067 : 1 : if (sock_flag(sk, SOCK_DONE))
2068 : : break;
2069 : :
2070 : 1 : if (sk->sk_err) {
2071 : 0 : copied = sock_error(sk);
2072 : 0 : break;
2073 : : }
2074 : :
2075 : 1 : if (sk->sk_shutdown & RCV_SHUTDOWN)
2076 : : break;
2077 : :
2078 : 1 : if (sk->sk_state == TCP_CLOSE) {
2079 : : /* This occurs when user tries to read
2080 : : * from never connected socket.
2081 : : */
2082 : : copied = -ENOTCONN;
2083 : : break;
2084 : : }
2085 : :
2086 : 1 : if (!timeo) {
2087 : : copied = -EAGAIN;
2088 : : break;
2089 : : }
2090 : :
2091 : 0 : if (signal_pending(current)) {
2092 : 0 : copied = sock_intr_errno(timeo);
2093 : 0 : break;
2094 : : }
2095 : : }
2096 : :
2097 : 0 : tcp_cleanup_rbuf(sk, copied);
2098 : :
2099 : 0 : if (copied >= target) {
2100 : : /* Do not sleep, just process backlog. */
2101 : 0 : release_sock(sk);
2102 : : lock_sock(sk);
2103 : : } else {
2104 : 0 : sk_wait_data(sk, &timeo, last);
2105 : : }
2106 : :
2107 : 0 : if ((flags & MSG_PEEK) &&
2108 : 0 : (peek_seq - copied - urg_hole != tp->copied_seq)) {
2109 : : net_dbg_ratelimited("TCP(%s:%d): Application bug, race in MSG_PEEK\n",
2110 : : current->comm,
2111 : : task_pid_nr(current));
2112 : 0 : peek_seq = tp->copied_seq;
2113 : : }
2114 : 0 : continue;
2115 : :
2116 : : found_ok_skb:
2117 : : /* Ok so how much can we use? */
2118 : 1 : used = skb->len - offset;
2119 : 1 : if (len < used)
2120 : : used = len;
2121 : :
2122 : : /* Do we have urgent data here? */
2123 : 1 : if (tp->urg_data) {
2124 : 0 : u32 urg_offset = tp->urg_seq - *seq;
2125 : 0 : if (urg_offset < used) {
2126 : 0 : if (!urg_offset) {
2127 : 0 : if (!sock_flag(sk, SOCK_URGINLINE)) {
2128 : 0 : WRITE_ONCE(*seq, *seq + 1);
2129 : 0 : urg_hole++;
2130 : 0 : offset++;
2131 : 0 : used--;
2132 : 0 : if (!used)
2133 : : goto skip_copy;
2134 : : }
2135 : : } else
2136 : : used = urg_offset;
2137 : : }
2138 : : }
2139 : :
2140 : 1 : if (!(flags & MSG_TRUNC)) {
2141 : 1 : err = skb_copy_datagram_msg(skb, offset, msg, used);
2142 : 1 : if (err) {
2143 : : /* Exception. Bailout! */
2144 : 0 : if (!copied)
2145 : : copied = -EFAULT;
2146 : : break;
2147 : : }
2148 : : }
2149 : :
2150 : 1 : WRITE_ONCE(*seq, *seq + used);
2151 : 1 : copied += used;
2152 : 1 : len -= used;
2153 : :
2154 : 1 : tcp_rcv_space_adjust(sk);
2155 : :
2156 : : skip_copy:
2157 : 1 : if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
2158 : 0 : tp->urg_data = 0;
2159 : 0 : tcp_fast_path_check(sk);
2160 : : }
2161 : :
2162 : 1 : if (TCP_SKB_CB(skb)->has_rxtstamp) {
2163 : 0 : tcp_update_recv_tstamps(skb, &tss);
2164 : 0 : cmsg_flags |= 2;
2165 : : }
2166 : :
2167 : 1 : if (used + offset < skb->len)
2168 : 1 : continue;
2169 : :
2170 : 1 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
2171 : : goto found_fin_ok;
2172 : 1 : if (!(flags & MSG_PEEK))
2173 : 1 : sk_eat_skb(sk, skb);
2174 : 1 : continue;
2175 : :
2176 : : found_fin_ok:
2177 : : /* Process the FIN. */
2178 : 1 : WRITE_ONCE(*seq, *seq + 1);
2179 : 1 : if (!(flags & MSG_PEEK))
2180 : 1 : sk_eat_skb(sk, skb);
2181 : : break;
2182 : 1 : } while (len > 0);
2183 : :
2184 : : /* According to UNIX98, msg_name/msg_namelen are ignored
2185 : : * on connected socket. I was just happy when found this 8) --ANK
2186 : : */
2187 : :
2188 : : /* Clean up data we have read: This will do ACK frames. */
2189 : 1 : tcp_cleanup_rbuf(sk, copied);
2190 : :
2191 : 1 : release_sock(sk);
2192 : :
2193 : 1 : if (cmsg_flags) {
2194 : 0 : if (cmsg_flags & 2)
2195 : 0 : tcp_recv_timestamp(msg, sk, &tss);
2196 : 0 : if (cmsg_flags & 1) {
2197 : 0 : inq = tcp_inq_hint(sk);
2198 : 0 : put_cmsg(msg, SOL_TCP, TCP_CM_INQ, sizeof(inq), &inq);
2199 : : }
2200 : : }
2201 : :
2202 : 1 : return copied;
2203 : :
2204 : : out:
2205 : 0 : release_sock(sk);
2206 : 0 : return err;
2207 : :
2208 : : recv_urg:
2209 : 0 : err = tcp_recv_urg(sk, msg, len, flags);
2210 : 0 : goto out;
2211 : :
2212 : : recv_sndq:
2213 : 0 : err = tcp_peek_sndq(sk, msg, len);
2214 : 0 : goto out;
2215 : : }
2216 : : EXPORT_SYMBOL(tcp_recvmsg);
2217 : :
2218 : 1 : void tcp_set_state(struct sock *sk, int state)
2219 : : {
2220 : 1 : int oldstate = sk->sk_state;
2221 : :
2222 : : /* We defined a new enum for TCP states that are exported in BPF
2223 : : * so as not force the internal TCP states to be frozen. The
2224 : : * following checks will detect if an internal state value ever
2225 : : * differs from the BPF value. If this ever happens, then we will
2226 : : * need to remap the internal value to the BPF value before calling
2227 : : * tcp_call_bpf_2arg.
2228 : : */
2229 : : BUILD_BUG_ON((int)BPF_TCP_ESTABLISHED != (int)TCP_ESTABLISHED);
2230 : : BUILD_BUG_ON((int)BPF_TCP_SYN_SENT != (int)TCP_SYN_SENT);
2231 : : BUILD_BUG_ON((int)BPF_TCP_SYN_RECV != (int)TCP_SYN_RECV);
2232 : : BUILD_BUG_ON((int)BPF_TCP_FIN_WAIT1 != (int)TCP_FIN_WAIT1);
2233 : : BUILD_BUG_ON((int)BPF_TCP_FIN_WAIT2 != (int)TCP_FIN_WAIT2);
2234 : : BUILD_BUG_ON((int)BPF_TCP_TIME_WAIT != (int)TCP_TIME_WAIT);
2235 : : BUILD_BUG_ON((int)BPF_TCP_CLOSE != (int)TCP_CLOSE);
2236 : : BUILD_BUG_ON((int)BPF_TCP_CLOSE_WAIT != (int)TCP_CLOSE_WAIT);
2237 : : BUILD_BUG_ON((int)BPF_TCP_LAST_ACK != (int)TCP_LAST_ACK);
2238 : : BUILD_BUG_ON((int)BPF_TCP_LISTEN != (int)TCP_LISTEN);
2239 : : BUILD_BUG_ON((int)BPF_TCP_CLOSING != (int)TCP_CLOSING);
2240 : : BUILD_BUG_ON((int)BPF_TCP_NEW_SYN_RECV != (int)TCP_NEW_SYN_RECV);
2241 : : BUILD_BUG_ON((int)BPF_TCP_MAX_STATES != (int)TCP_MAX_STATES);
2242 : :
2243 : 1 : if (BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk), BPF_SOCK_OPS_STATE_CB_FLAG))
2244 : 0 : tcp_call_bpf_2arg(sk, BPF_SOCK_OPS_STATE_CB, oldstate, state);
2245 : :
2246 : 1 : switch (state) {
2247 : : case TCP_ESTABLISHED:
2248 : 1 : if (oldstate != TCP_ESTABLISHED)
2249 : 1 : TCP_INC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
2250 : : break;
2251 : :
2252 : : case TCP_CLOSE:
2253 : 1 : if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
2254 : 1 : TCP_INC_STATS(sock_net(sk), TCP_MIB_ESTABRESETS);
2255 : :
2256 : 1 : sk->sk_prot->unhash(sk);
2257 : 1 : if (inet_csk(sk)->icsk_bind_hash &&
2258 : 1 : !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
2259 : 1 : inet_put_port(sk);
2260 : : /* fall through */
2261 : : default:
2262 : 1 : if (oldstate == TCP_ESTABLISHED)
2263 : 1 : TCP_DEC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
2264 : : }
2265 : :
2266 : : /* Change state AFTER socket is unhashed to avoid closed
2267 : : * socket sitting in hash tables.
2268 : : */
2269 : 1 : inet_sk_state_store(sk, state);
2270 : 1 : }
2271 : : EXPORT_SYMBOL_GPL(tcp_set_state);
2272 : :
2273 : : /*
2274 : : * State processing on a close. This implements the state shift for
2275 : : * sending our FIN frame. Note that we only send a FIN for some
2276 : : * states. A shutdown() may have already sent the FIN, or we may be
2277 : : * closed.
2278 : : */
2279 : :
2280 : : static const unsigned char new_state[16] = {
2281 : : /* current state: new state: action: */
2282 : : [0 /* (Invalid) */] = TCP_CLOSE,
2283 : : [TCP_ESTABLISHED] = TCP_FIN_WAIT1 | TCP_ACTION_FIN,
2284 : : [TCP_SYN_SENT] = TCP_CLOSE,
2285 : : [TCP_SYN_RECV] = TCP_FIN_WAIT1 | TCP_ACTION_FIN,
2286 : : [TCP_FIN_WAIT1] = TCP_FIN_WAIT1,
2287 : : [TCP_FIN_WAIT2] = TCP_FIN_WAIT2,
2288 : : [TCP_TIME_WAIT] = TCP_CLOSE,
2289 : : [TCP_CLOSE] = TCP_CLOSE,
2290 : : [TCP_CLOSE_WAIT] = TCP_LAST_ACK | TCP_ACTION_FIN,
2291 : : [TCP_LAST_ACK] = TCP_LAST_ACK,
2292 : : [TCP_LISTEN] = TCP_CLOSE,
2293 : : [TCP_CLOSING] = TCP_CLOSING,
2294 : : [TCP_NEW_SYN_RECV] = TCP_CLOSE, /* should not happen ! */
2295 : : };
2296 : :
2297 : : static int tcp_close_state(struct sock *sk)
2298 : : {
2299 : 1 : int next = (int)new_state[sk->sk_state];
2300 : 1 : int ns = next & TCP_STATE_MASK;
2301 : :
2302 : 1 : tcp_set_state(sk, ns);
2303 : :
2304 : 1 : return next & TCP_ACTION_FIN;
2305 : : }
2306 : :
2307 : : /*
2308 : : * Shutdown the sending side of a connection. Much like close except
2309 : : * that we don't receive shut down or sock_set_flag(sk, SOCK_DEAD).
2310 : : */
2311 : :
2312 : 0 : void tcp_shutdown(struct sock *sk, int how)
2313 : : {
2314 : : /* We need to grab some memory, and put together a FIN,
2315 : : * and then put it into the queue to be sent.
2316 : : * Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
2317 : : */
2318 : 0 : if (!(how & SEND_SHUTDOWN))
2319 : 0 : return;
2320 : :
2321 : : /* If we've already sent a FIN, or it's a closed state, skip this. */
2322 : 0 : if ((1 << sk->sk_state) &
2323 : : (TCPF_ESTABLISHED | TCPF_SYN_SENT |
2324 : : TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
2325 : : /* Clear out any half completed packets. FIN if needed. */
2326 : 0 : if (tcp_close_state(sk))
2327 : 0 : tcp_send_fin(sk);
2328 : : }
2329 : : }
2330 : : EXPORT_SYMBOL(tcp_shutdown);
2331 : :
2332 : 1 : bool tcp_check_oom(struct sock *sk, int shift)
2333 : : {
2334 : : bool too_many_orphans, out_of_socket_memory;
2335 : :
2336 : 1 : too_many_orphans = tcp_too_many_orphans(sk, shift);
2337 : : out_of_socket_memory = tcp_out_of_memory(sk);
2338 : :
2339 : 1 : if (too_many_orphans)
2340 : 0 : net_info_ratelimited("too many orphaned sockets\n");
2341 : 1 : if (out_of_socket_memory)
2342 : 0 : net_info_ratelimited("out of memory -- consider tuning tcp_mem\n");
2343 : 1 : return too_many_orphans || out_of_socket_memory;
2344 : : }
2345 : :
2346 : 1 : void tcp_close(struct sock *sk, long timeout)
2347 : : {
2348 : : struct sk_buff *skb;
2349 : : int data_was_unread = 0;
2350 : : int state;
2351 : :
2352 : : lock_sock(sk);
2353 : 1 : sk->sk_shutdown = SHUTDOWN_MASK;
2354 : :
2355 : 1 : if (sk->sk_state == TCP_LISTEN) {
2356 : 0 : tcp_set_state(sk, TCP_CLOSE);
2357 : :
2358 : : /* Special case. */
2359 : 0 : inet_csk_listen_stop(sk);
2360 : :
2361 : 0 : goto adjudge_to_death;
2362 : : }
2363 : :
2364 : : /* We need to flush the recv. buffs. We do this only on the
2365 : : * descriptor close, not protocol-sourced closes, because the
2366 : : * reader process may not have drained the data yet!
2367 : : */
2368 : 1 : while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
2369 : 1 : u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq;
2370 : :
2371 : 1 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
2372 : 0 : len--;
2373 : 1 : data_was_unread += len;
2374 : 1 : __kfree_skb(skb);
2375 : : }
2376 : :
2377 : 1 : sk_mem_reclaim(sk);
2378 : :
2379 : : /* If socket has been already reset (e.g. in tcp_reset()) - kill it. */
2380 : 1 : if (sk->sk_state == TCP_CLOSE)
2381 : : goto adjudge_to_death;
2382 : :
2383 : : /* As outlined in RFC 2525, section 2.17, we send a RST here because
2384 : : * data was lost. To witness the awful effects of the old behavior of
2385 : : * always doing a FIN, run an older 2.1.x kernel or 2.0.x, start a bulk
2386 : : * GET in an FTP client, suspend the process, wait for the client to
2387 : : * advertise a zero window, then kill -9 the FTP client, wheee...
2388 : : * Note: timeout is always zero in such a case.
2389 : : */
2390 : 1 : if (unlikely(tcp_sk(sk)->repair)) {
2391 : 0 : sk->sk_prot->disconnect(sk, 0);
2392 : 1 : } else if (data_was_unread) {
2393 : : /* Unread data was tossed, zap the connection. */
2394 : 1 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONCLOSE);
2395 : 1 : tcp_set_state(sk, TCP_CLOSE);
2396 : 1 : tcp_send_active_reset(sk, sk->sk_allocation);
2397 : 1 : } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
2398 : : /* Check zero linger _after_ checking for unread data. */
2399 : 0 : sk->sk_prot->disconnect(sk, 0);
2400 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
2401 : 1 : } else if (tcp_close_state(sk)) {
2402 : : /* We FIN if the application ate all the data before
2403 : : * zapping the connection.
2404 : : */
2405 : :
2406 : : /* RED-PEN. Formally speaking, we have broken TCP state
2407 : : * machine. State transitions:
2408 : : *
2409 : : * TCP_ESTABLISHED -> TCP_FIN_WAIT1
2410 : : * TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
2411 : : * TCP_CLOSE_WAIT -> TCP_LAST_ACK
2412 : : *
2413 : : * are legal only when FIN has been sent (i.e. in window),
2414 : : * rather than queued out of window. Purists blame.
2415 : : *
2416 : : * F.e. "RFC state" is ESTABLISHED,
2417 : : * if Linux state is FIN-WAIT-1, but FIN is still not sent.
2418 : : *
2419 : : * The visible declinations are that sometimes
2420 : : * we enter time-wait state, when it is not required really
2421 : : * (harmless), do not send active resets, when they are
2422 : : * required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
2423 : : * they look as CLOSING or LAST_ACK for Linux)
2424 : : * Probably, I missed some more holelets.
2425 : : * --ANK
2426 : : * XXX (TFO) - To start off we don't support SYN+ACK+FIN
2427 : : * in a single packet! (May consider it later but will
2428 : : * probably need API support or TCP_CORK SYN-ACK until
2429 : : * data is written and socket is closed.)
2430 : : */
2431 : 1 : tcp_send_fin(sk);
2432 : : }
2433 : :
2434 : 1 : sk_stream_wait_close(sk, timeout);
2435 : :
2436 : : adjudge_to_death:
2437 : 1 : state = sk->sk_state;
2438 : : sock_hold(sk);
2439 : 1 : sock_orphan(sk);
2440 : :
2441 : : local_bh_disable();
2442 : : bh_lock_sock(sk);
2443 : : /* remove backlog if any, without releasing ownership. */
2444 : 1 : __release_sock(sk);
2445 : :
2446 : 1 : percpu_counter_inc(sk->sk_prot->orphan_count);
2447 : :
2448 : : /* Have we already been destroyed by a softirq or backlog? */
2449 : 1 : if (state != TCP_CLOSE && sk->sk_state == TCP_CLOSE)
2450 : : goto out;
2451 : :
2452 : : /* This is a (useful) BSD violating of the RFC. There is a
2453 : : * problem with TCP as specified in that the other end could
2454 : : * keep a socket open forever with no application left this end.
2455 : : * We use a 1 minute timeout (about the same as BSD) then kill
2456 : : * our end. If they send after that then tough - BUT: long enough
2457 : : * that we won't make the old 4*rto = almost no time - whoops
2458 : : * reset mistake.
2459 : : *
2460 : : * Nope, it was not mistake. It is really desired behaviour
2461 : : * f.e. on http servers, when such sockets are useless, but
2462 : : * consume significant resources. Let's do it with special
2463 : : * linger2 option. --ANK
2464 : : */
2465 : :
2466 : 1 : if (sk->sk_state == TCP_FIN_WAIT2) {
2467 : : struct tcp_sock *tp = tcp_sk(sk);
2468 : 0 : if (tp->linger2 < 0) {
2469 : 0 : tcp_set_state(sk, TCP_CLOSE);
2470 : 0 : tcp_send_active_reset(sk, GFP_ATOMIC);
2471 : 0 : __NET_INC_STATS(sock_net(sk),
2472 : : LINUX_MIB_TCPABORTONLINGER);
2473 : : } else {
2474 : : const int tmo = tcp_fin_time(sk);
2475 : :
2476 : 0 : if (tmo > TCP_TIMEWAIT_LEN) {
2477 : 0 : inet_csk_reset_keepalive_timer(sk,
2478 : 0 : tmo - TCP_TIMEWAIT_LEN);
2479 : : } else {
2480 : 0 : tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
2481 : 0 : goto out;
2482 : : }
2483 : : }
2484 : : }
2485 : 1 : if (sk->sk_state != TCP_CLOSE) {
2486 : 1 : sk_mem_reclaim(sk);
2487 : 1 : if (tcp_check_oom(sk, 0)) {
2488 : 0 : tcp_set_state(sk, TCP_CLOSE);
2489 : 0 : tcp_send_active_reset(sk, GFP_ATOMIC);
2490 : 0 : __NET_INC_STATS(sock_net(sk),
2491 : : LINUX_MIB_TCPABORTONMEMORY);
2492 : 1 : } else if (!check_net(sock_net(sk))) {
2493 : : /* Not possible to send reset; just close */
2494 : 0 : tcp_set_state(sk, TCP_CLOSE);
2495 : : }
2496 : : }
2497 : :
2498 : 1 : if (sk->sk_state == TCP_CLOSE) {
2499 : : struct request_sock *req;
2500 : :
2501 : 1 : req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk,
2502 : : lockdep_sock_is_held(sk));
2503 : : /* We could get here with a non-NULL req if the socket is
2504 : : * aborted (e.g., closed with unread data) before 3WHS
2505 : : * finishes.
2506 : : */
2507 : 1 : if (req)
2508 : 0 : reqsk_fastopen_remove(sk, req, false);
2509 : 1 : inet_csk_destroy_sock(sk);
2510 : : }
2511 : : /* Otherwise, socket is reprieved until protocol close. */
2512 : :
2513 : : out:
2514 : : bh_unlock_sock(sk);
2515 : : local_bh_enable();
2516 : 1 : release_sock(sk);
2517 : 1 : sock_put(sk);
2518 : 1 : }
2519 : : EXPORT_SYMBOL(tcp_close);
2520 : :
2521 : : /* These states need RST on ABORT according to RFC793 */
2522 : :
2523 : : static inline bool tcp_need_reset(int state)
2524 : : {
2525 : 0 : return (1 << state) &
2526 : : (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 |
2527 : : TCPF_FIN_WAIT2 | TCPF_SYN_RECV);
2528 : : }
2529 : :
2530 : 1 : static void tcp_rtx_queue_purge(struct sock *sk)
2531 : : {
2532 : 1 : struct rb_node *p = rb_first(&sk->tcp_rtx_queue);
2533 : :
2534 : 1 : tcp_sk(sk)->highest_sack = NULL;
2535 : 1 : while (p) {
2536 : 0 : struct sk_buff *skb = rb_to_skb(p);
2537 : :
2538 : 0 : p = rb_next(p);
2539 : : /* Since we are deleting whole queue, no need to
2540 : : * list_del(&skb->tcp_tsorted_anchor)
2541 : : */
2542 : : tcp_rtx_queue_unlink(skb, sk);
2543 : 0 : sk_wmem_free_skb(sk, skb);
2544 : : }
2545 : 1 : }
2546 : :
2547 : 1 : void tcp_write_queue_purge(struct sock *sk)
2548 : : {
2549 : : struct sk_buff *skb;
2550 : :
2551 : 1 : tcp_chrono_stop(sk, TCP_CHRONO_BUSY);
2552 : 1 : while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
2553 : : tcp_skb_tsorted_anchor_cleanup(skb);
2554 : 0 : sk_wmem_free_skb(sk, skb);
2555 : : }
2556 : 1 : tcp_rtx_queue_purge(sk);
2557 : 1 : skb = sk->sk_tx_skb_cache;
2558 : 1 : if (skb) {
2559 : 0 : __kfree_skb(skb);
2560 : 0 : sk->sk_tx_skb_cache = NULL;
2561 : : }
2562 : 1 : INIT_LIST_HEAD(&tcp_sk(sk)->tsorted_sent_queue);
2563 : 1 : sk_mem_reclaim(sk);
2564 : : tcp_clear_all_retrans_hints(tcp_sk(sk));
2565 : 1 : tcp_sk(sk)->packets_out = 0;
2566 : 1 : inet_csk(sk)->icsk_backoff = 0;
2567 : 1 : }
2568 : :
2569 : 0 : int tcp_disconnect(struct sock *sk, int flags)
2570 : : {
2571 : : struct inet_sock *inet = inet_sk(sk);
2572 : : struct inet_connection_sock *icsk = inet_csk(sk);
2573 : : struct tcp_sock *tp = tcp_sk(sk);
2574 : 0 : int old_state = sk->sk_state;
2575 : : u32 seq;
2576 : :
2577 : 0 : if (old_state != TCP_CLOSE)
2578 : 0 : tcp_set_state(sk, TCP_CLOSE);
2579 : :
2580 : : /* ABORT function of RFC793 */
2581 : 0 : if (old_state == TCP_LISTEN) {
2582 : 0 : inet_csk_listen_stop(sk);
2583 : 0 : } else if (unlikely(tp->repair)) {
2584 : 0 : sk->sk_err = ECONNABORTED;
2585 : 0 : } else if (tcp_need_reset(old_state) ||
2586 : 0 : (tp->snd_nxt != tp->write_seq &&
2587 : : (1 << old_state) & (TCPF_CLOSING | TCPF_LAST_ACK))) {
2588 : : /* The last check adjusts for discrepancy of Linux wrt. RFC
2589 : : * states
2590 : : */
2591 : 0 : tcp_send_active_reset(sk, gfp_any());
2592 : 0 : sk->sk_err = ECONNRESET;
2593 : 0 : } else if (old_state == TCP_SYN_SENT)
2594 : 0 : sk->sk_err = ECONNRESET;
2595 : :
2596 : 0 : tcp_clear_xmit_timers(sk);
2597 : 0 : __skb_queue_purge(&sk->sk_receive_queue);
2598 : 0 : if (sk->sk_rx_skb_cache) {
2599 : 0 : __kfree_skb(sk->sk_rx_skb_cache);
2600 : 0 : sk->sk_rx_skb_cache = NULL;
2601 : : }
2602 : 0 : WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
2603 : 0 : tp->urg_data = 0;
2604 : 0 : tcp_write_queue_purge(sk);
2605 : 0 : tcp_fastopen_active_disable_ofo_check(sk);
2606 : 0 : skb_rbtree_purge(&tp->out_of_order_queue);
2607 : :
2608 : 0 : inet->inet_dport = 0;
2609 : :
2610 : 0 : if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
2611 : 0 : inet_reset_saddr(sk);
2612 : :
2613 : 0 : sk->sk_shutdown = 0;
2614 : : sock_reset_flag(sk, SOCK_DONE);
2615 : 0 : tp->srtt_us = 0;
2616 : 0 : tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
2617 : 0 : tp->rcv_rtt_last_tsecr = 0;
2618 : :
2619 : 0 : seq = tp->write_seq + tp->max_window + 2;
2620 : 0 : if (!seq)
2621 : : seq = 1;
2622 : : WRITE_ONCE(tp->write_seq, seq);
2623 : :
2624 : 0 : icsk->icsk_backoff = 0;
2625 : 0 : tp->snd_cwnd = 2;
2626 : 0 : icsk->icsk_probes_out = 0;
2627 : 0 : icsk->icsk_rto = TCP_TIMEOUT_INIT;
2628 : 0 : tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
2629 : 0 : tp->snd_cwnd = TCP_INIT_CWND;
2630 : 0 : tp->snd_cwnd_cnt = 0;
2631 : 0 : tp->window_clamp = 0;
2632 : 0 : tp->delivered = 0;
2633 : 0 : tp->delivered_ce = 0;
2634 : 0 : if (icsk->icsk_ca_ops->release)
2635 : 0 : icsk->icsk_ca_ops->release(sk);
2636 : 0 : memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
2637 : : tcp_set_ca_state(sk, TCP_CA_Open);
2638 : 0 : tp->is_sack_reneg = 0;
2639 : 0 : tcp_clear_retrans(tp);
2640 : 0 : tp->total_retrans = 0;
2641 : : inet_csk_delack_init(sk);
2642 : : /* Initialize rcv_mss to TCP_MIN_MSS to avoid division by 0
2643 : : * issue in __tcp_select_window()
2644 : : */
2645 : 0 : icsk->icsk_ack.rcv_mss = TCP_MIN_MSS;
2646 : 0 : memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
2647 : : __sk_dst_reset(sk);
2648 : 0 : dst_release(sk->sk_rx_dst);
2649 : 0 : sk->sk_rx_dst = NULL;
2650 : : tcp_saved_syn_free(tp);
2651 : 0 : tp->compressed_ack = 0;
2652 : 0 : tp->segs_in = 0;
2653 : 0 : tp->segs_out = 0;
2654 : 0 : tp->bytes_sent = 0;
2655 : 0 : tp->bytes_acked = 0;
2656 : 0 : tp->bytes_received = 0;
2657 : 0 : tp->bytes_retrans = 0;
2658 : 0 : tp->data_segs_in = 0;
2659 : 0 : tp->data_segs_out = 0;
2660 : 0 : tp->duplicate_sack[0].start_seq = 0;
2661 : 0 : tp->duplicate_sack[0].end_seq = 0;
2662 : 0 : tp->dsack_dups = 0;
2663 : 0 : tp->reord_seen = 0;
2664 : 0 : tp->retrans_out = 0;
2665 : 0 : tp->sacked_out = 0;
2666 : 0 : tp->tlp_high_seq = 0;
2667 : 0 : tp->last_oow_ack_time = 0;
2668 : : /* There's a bubble in the pipe until at least the first ACK. */
2669 : 0 : tp->app_limited = ~0U;
2670 : 0 : tp->rack.mstamp = 0;
2671 : 0 : tp->rack.advanced = 0;
2672 : 0 : tp->rack.reo_wnd_steps = 1;
2673 : 0 : tp->rack.last_delivered = 0;
2674 : 0 : tp->rack.reo_wnd_persist = 0;
2675 : 0 : tp->rack.dsack_seen = 0;
2676 : 0 : tp->syn_data_acked = 0;
2677 : 0 : tp->rx_opt.saw_tstamp = 0;
2678 : 0 : tp->rx_opt.dsack = 0;
2679 : 0 : tp->rx_opt.num_sacks = 0;
2680 : 0 : tp->rcv_ooopack = 0;
2681 : :
2682 : :
2683 : : /* Clean up fastopen related fields */
2684 : : tcp_free_fastopen_req(tp);
2685 : 0 : inet->defer_connect = 0;
2686 : :
2687 : 0 : WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
2688 : :
2689 : 0 : if (sk->sk_frag.page) {
2690 : 0 : put_page(sk->sk_frag.page);
2691 : 0 : sk->sk_frag.page = NULL;
2692 : 0 : sk->sk_frag.offset = 0;
2693 : : }
2694 : :
2695 : 0 : sk->sk_error_report(sk);
2696 : 0 : return 0;
2697 : : }
2698 : : EXPORT_SYMBOL(tcp_disconnect);
2699 : :
2700 : 0 : static inline bool tcp_can_repair_sock(const struct sock *sk)
2701 : : {
2702 : 0 : return ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN) &&
2703 : 0 : (sk->sk_state != TCP_LISTEN);
2704 : : }
2705 : :
2706 : 0 : static int tcp_repair_set_window(struct tcp_sock *tp, char __user *optbuf, int len)
2707 : : {
2708 : : struct tcp_repair_window opt;
2709 : :
2710 : 0 : if (!tp->repair)
2711 : : return -EPERM;
2712 : :
2713 : 0 : if (len != sizeof(opt))
2714 : : return -EINVAL;
2715 : :
2716 : 0 : if (copy_from_user(&opt, optbuf, sizeof(opt)))
2717 : : return -EFAULT;
2718 : :
2719 : 0 : if (opt.max_window < opt.snd_wnd)
2720 : : return -EINVAL;
2721 : :
2722 : 0 : if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd))
2723 : : return -EINVAL;
2724 : :
2725 : 0 : if (after(opt.rcv_wup, tp->rcv_nxt))
2726 : : return -EINVAL;
2727 : :
2728 : 0 : tp->snd_wl1 = opt.snd_wl1;
2729 : 0 : tp->snd_wnd = opt.snd_wnd;
2730 : 0 : tp->max_window = opt.max_window;
2731 : :
2732 : 0 : tp->rcv_wnd = opt.rcv_wnd;
2733 : 0 : tp->rcv_wup = opt.rcv_wup;
2734 : :
2735 : 0 : return 0;
2736 : : }
2737 : :
2738 : 0 : static int tcp_repair_options_est(struct sock *sk,
2739 : : struct tcp_repair_opt __user *optbuf, unsigned int len)
2740 : : {
2741 : : struct tcp_sock *tp = tcp_sk(sk);
2742 : : struct tcp_repair_opt opt;
2743 : :
2744 : 0 : while (len >= sizeof(opt)) {
2745 : 0 : if (copy_from_user(&opt, optbuf, sizeof(opt)))
2746 : : return -EFAULT;
2747 : :
2748 : 0 : optbuf++;
2749 : 0 : len -= sizeof(opt);
2750 : :
2751 : 0 : switch (opt.opt_code) {
2752 : : case TCPOPT_MSS:
2753 : 0 : tp->rx_opt.mss_clamp = opt.opt_val;
2754 : 0 : tcp_mtup_init(sk);
2755 : 0 : break;
2756 : : case TCPOPT_WINDOW:
2757 : : {
2758 : 0 : u16 snd_wscale = opt.opt_val & 0xFFFF;
2759 : 0 : u16 rcv_wscale = opt.opt_val >> 16;
2760 : :
2761 : 0 : if (snd_wscale > TCP_MAX_WSCALE || rcv_wscale > TCP_MAX_WSCALE)
2762 : : return -EFBIG;
2763 : :
2764 : 0 : tp->rx_opt.snd_wscale = snd_wscale;
2765 : 0 : tp->rx_opt.rcv_wscale = rcv_wscale;
2766 : 0 : tp->rx_opt.wscale_ok = 1;
2767 : : }
2768 : 0 : break;
2769 : : case TCPOPT_SACK_PERM:
2770 : 0 : if (opt.opt_val != 0)
2771 : : return -EINVAL;
2772 : :
2773 : 0 : tp->rx_opt.sack_ok |= TCP_SACK_SEEN;
2774 : 0 : break;
2775 : : case TCPOPT_TIMESTAMP:
2776 : 0 : if (opt.opt_val != 0)
2777 : : return -EINVAL;
2778 : :
2779 : 0 : tp->rx_opt.tstamp_ok = 1;
2780 : 0 : break;
2781 : : }
2782 : : }
2783 : :
2784 : : return 0;
2785 : : }
2786 : :
2787 : : DEFINE_STATIC_KEY_FALSE(tcp_tx_delay_enabled);
2788 : : EXPORT_SYMBOL(tcp_tx_delay_enabled);
2789 : :
2790 : 0 : static void tcp_enable_tx_delay(void)
2791 : : {
2792 : 0 : if (!static_branch_unlikely(&tcp_tx_delay_enabled)) {
2793 : : static int __tcp_tx_delay_enabled = 0;
2794 : :
2795 : 0 : if (cmpxchg(&__tcp_tx_delay_enabled, 0, 1) == 0) {
2796 : 0 : static_branch_enable(&tcp_tx_delay_enabled);
2797 : 0 : pr_info("TCP_TX_DELAY enabled\n");
2798 : : }
2799 : : }
2800 : 0 : }
2801 : :
2802 : : /*
2803 : : * Socket option code for TCP.
2804 : : */
2805 : 1 : static int do_tcp_setsockopt(struct sock *sk, int level,
2806 : : int optname, char __user *optval, unsigned int optlen)
2807 : : {
2808 : : struct tcp_sock *tp = tcp_sk(sk);
2809 : : struct inet_connection_sock *icsk = inet_csk(sk);
2810 : : struct net *net = sock_net(sk);
2811 : : int val;
2812 : : int err = 0;
2813 : :
2814 : : /* These are data/string values, all the others are ints */
2815 : 1 : switch (optname) {
2816 : : case TCP_CONGESTION: {
2817 : : char name[TCP_CA_NAME_MAX];
2818 : :
2819 : 0 : if (optlen < 1)
2820 : : return -EINVAL;
2821 : :
2822 : 0 : val = strncpy_from_user(name, optval,
2823 : 0 : min_t(long, TCP_CA_NAME_MAX-1, optlen));
2824 : 0 : if (val < 0)
2825 : : return -EFAULT;
2826 : 0 : name[val] = 0;
2827 : :
2828 : : lock_sock(sk);
2829 : 0 : err = tcp_set_congestion_control(sk, name, true, true,
2830 : : ns_capable(sock_net(sk)->user_ns,
2831 : : CAP_NET_ADMIN));
2832 : 0 : release_sock(sk);
2833 : 0 : return err;
2834 : : }
2835 : : case TCP_ULP: {
2836 : : char name[TCP_ULP_NAME_MAX];
2837 : :
2838 : 0 : if (optlen < 1)
2839 : : return -EINVAL;
2840 : :
2841 : 0 : val = strncpy_from_user(name, optval,
2842 : 0 : min_t(long, TCP_ULP_NAME_MAX - 1,
2843 : : optlen));
2844 : 0 : if (val < 0)
2845 : : return -EFAULT;
2846 : 0 : name[val] = 0;
2847 : :
2848 : : lock_sock(sk);
2849 : 0 : err = tcp_set_ulp(sk, name);
2850 : 0 : release_sock(sk);
2851 : 0 : return err;
2852 : : }
2853 : : case TCP_FASTOPEN_KEY: {
2854 : : __u8 key[TCP_FASTOPEN_KEY_BUF_LENGTH];
2855 : : __u8 *backup_key = NULL;
2856 : :
2857 : : /* Allow a backup key as well to facilitate key rotation
2858 : : * First key is the active one.
2859 : : */
2860 : 0 : if (optlen != TCP_FASTOPEN_KEY_LENGTH &&
2861 : 0 : optlen != TCP_FASTOPEN_KEY_BUF_LENGTH)
2862 : : return -EINVAL;
2863 : :
2864 : 0 : if (copy_from_user(key, optval, optlen))
2865 : : return -EFAULT;
2866 : :
2867 : 0 : if (optlen == TCP_FASTOPEN_KEY_BUF_LENGTH)
2868 : : backup_key = key + TCP_FASTOPEN_KEY_LENGTH;
2869 : :
2870 : 0 : return tcp_fastopen_reset_cipher(net, sk, key, backup_key);
2871 : : }
2872 : : default:
2873 : : /* fallthru */
2874 : : break;
2875 : : }
2876 : :
2877 : 1 : if (optlen < sizeof(int))
2878 : : return -EINVAL;
2879 : :
2880 : 1 : if (get_user(val, (int __user *)optval))
2881 : : return -EFAULT;
2882 : :
2883 : : lock_sock(sk);
2884 : :
2885 : 1 : switch (optname) {
2886 : : case TCP_MAXSEG:
2887 : : /* Values greater than interface MTU won't take effect. However
2888 : : * at the point when this call is done we typically don't yet
2889 : : * know which interface is going to be used
2890 : : */
2891 : 0 : if (val && (val < TCP_MIN_MSS || val > MAX_TCP_WINDOW)) {
2892 : : err = -EINVAL;
2893 : : break;
2894 : : }
2895 : 0 : tp->rx_opt.user_mss = val;
2896 : 0 : break;
2897 : :
2898 : : case TCP_NODELAY:
2899 : 1 : if (val) {
2900 : : /* TCP_NODELAY is weaker than TCP_CORK, so that
2901 : : * this option on corked socket is remembered, but
2902 : : * it is not activated until cork is cleared.
2903 : : *
2904 : : * However, when TCP_NODELAY is set we make
2905 : : * an explicit push, which overrides even TCP_CORK
2906 : : * for currently queued segments.
2907 : : */
2908 : 1 : tp->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH;
2909 : 1 : tcp_push_pending_frames(sk);
2910 : : } else {
2911 : 0 : tp->nonagle &= ~TCP_NAGLE_OFF;
2912 : : }
2913 : : break;
2914 : :
2915 : : case TCP_THIN_LINEAR_TIMEOUTS:
2916 : 0 : if (val < 0 || val > 1)
2917 : : err = -EINVAL;
2918 : : else
2919 : 0 : tp->thin_lto = val;
2920 : : break;
2921 : :
2922 : : case TCP_THIN_DUPACK:
2923 : 0 : if (val < 0 || val > 1)
2924 : : err = -EINVAL;
2925 : : break;
2926 : :
2927 : : case TCP_REPAIR:
2928 : 0 : if (!tcp_can_repair_sock(sk))
2929 : : err = -EPERM;
2930 : 0 : else if (val == TCP_REPAIR_ON) {
2931 : 0 : tp->repair = 1;
2932 : 0 : sk->sk_reuse = SK_FORCE_REUSE;
2933 : 0 : tp->repair_queue = TCP_NO_QUEUE;
2934 : 0 : } else if (val == TCP_REPAIR_OFF) {
2935 : 0 : tp->repair = 0;
2936 : 0 : sk->sk_reuse = SK_NO_REUSE;
2937 : 0 : tcp_send_window_probe(sk);
2938 : 0 : } else if (val == TCP_REPAIR_OFF_NO_WP) {
2939 : 0 : tp->repair = 0;
2940 : 0 : sk->sk_reuse = SK_NO_REUSE;
2941 : : } else
2942 : : err = -EINVAL;
2943 : :
2944 : : break;
2945 : :
2946 : : case TCP_REPAIR_QUEUE:
2947 : 0 : if (!tp->repair)
2948 : : err = -EPERM;
2949 : 0 : else if ((unsigned int)val < TCP_QUEUES_NR)
2950 : 0 : tp->repair_queue = val;
2951 : : else
2952 : : err = -EINVAL;
2953 : : break;
2954 : :
2955 : : case TCP_QUEUE_SEQ:
2956 : 0 : if (sk->sk_state != TCP_CLOSE)
2957 : : err = -EPERM;
2958 : 0 : else if (tp->repair_queue == TCP_SEND_QUEUE)
2959 : : WRITE_ONCE(tp->write_seq, val);
2960 : 0 : else if (tp->repair_queue == TCP_RECV_QUEUE) {
2961 : : WRITE_ONCE(tp->rcv_nxt, val);
2962 : : WRITE_ONCE(tp->copied_seq, val);
2963 : : }
2964 : : else
2965 : : err = -EINVAL;
2966 : : break;
2967 : :
2968 : : case TCP_REPAIR_OPTIONS:
2969 : 0 : if (!tp->repair)
2970 : : err = -EINVAL;
2971 : 0 : else if (sk->sk_state == TCP_ESTABLISHED)
2972 : 0 : err = tcp_repair_options_est(sk,
2973 : : (struct tcp_repair_opt __user *)optval,
2974 : : optlen);
2975 : : else
2976 : : err = -EPERM;
2977 : : break;
2978 : :
2979 : : case TCP_CORK:
2980 : : /* When set indicates to always queue non-full frames.
2981 : : * Later the user clears this option and we transmit
2982 : : * any pending partial frames in the queue. This is
2983 : : * meant to be used alongside sendfile() to get properly
2984 : : * filled frames when the user (for example) must write
2985 : : * out headers with a write() call first and then use
2986 : : * sendfile to send out the data parts.
2987 : : *
2988 : : * TCP_CORK can be set together with TCP_NODELAY and it is
2989 : : * stronger than TCP_NODELAY.
2990 : : */
2991 : 0 : if (val) {
2992 : 0 : tp->nonagle |= TCP_NAGLE_CORK;
2993 : : } else {
2994 : 0 : tp->nonagle &= ~TCP_NAGLE_CORK;
2995 : 0 : if (tp->nonagle&TCP_NAGLE_OFF)
2996 : 0 : tp->nonagle |= TCP_NAGLE_PUSH;
2997 : 0 : tcp_push_pending_frames(sk);
2998 : : }
2999 : : break;
3000 : :
3001 : : case TCP_KEEPIDLE:
3002 : 1 : if (val < 1 || val > MAX_TCP_KEEPIDLE)
3003 : : err = -EINVAL;
3004 : : else {
3005 : 1 : tp->keepalive_time = val * HZ;
3006 : 1 : if (sock_flag(sk, SOCK_KEEPOPEN) &&
3007 : 1 : !((1 << sk->sk_state) &
3008 : : (TCPF_CLOSE | TCPF_LISTEN))) {
3009 : : u32 elapsed = keepalive_time_elapsed(tp);
3010 : 0 : if (tp->keepalive_time > elapsed)
3011 : 0 : elapsed = tp->keepalive_time - elapsed;
3012 : : else
3013 : : elapsed = 0;
3014 : 0 : inet_csk_reset_keepalive_timer(sk, elapsed);
3015 : : }
3016 : : }
3017 : : break;
3018 : : case TCP_KEEPINTVL:
3019 : 1 : if (val < 1 || val > MAX_TCP_KEEPINTVL)
3020 : : err = -EINVAL;
3021 : : else
3022 : 1 : tp->keepalive_intvl = val * HZ;
3023 : : break;
3024 : : case TCP_KEEPCNT:
3025 : 0 : if (val < 1 || val > MAX_TCP_KEEPCNT)
3026 : : err = -EINVAL;
3027 : : else
3028 : 0 : tp->keepalive_probes = val;
3029 : : break;
3030 : : case TCP_SYNCNT:
3031 : 0 : if (val < 1 || val > MAX_TCP_SYNCNT)
3032 : : err = -EINVAL;
3033 : : else
3034 : 0 : icsk->icsk_syn_retries = val;
3035 : : break;
3036 : :
3037 : : case TCP_SAVE_SYN:
3038 : 0 : if (val < 0 || val > 1)
3039 : : err = -EINVAL;
3040 : : else
3041 : 0 : tp->save_syn = val;
3042 : : break;
3043 : :
3044 : : case TCP_LINGER2:
3045 : 0 : if (val < 0)
3046 : 0 : tp->linger2 = -1;
3047 : 0 : else if (val > net->ipv4.sysctl_tcp_fin_timeout / HZ)
3048 : 0 : tp->linger2 = 0;
3049 : : else
3050 : 0 : tp->linger2 = val * HZ;
3051 : : break;
3052 : :
3053 : : case TCP_DEFER_ACCEPT:
3054 : : /* Translate value in seconds to number of retransmits */
3055 : 0 : icsk->icsk_accept_queue.rskq_defer_accept =
3056 : : secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ,
3057 : : TCP_RTO_MAX / HZ);
3058 : 0 : break;
3059 : :
3060 : : case TCP_WINDOW_CLAMP:
3061 : 0 : if (!val) {
3062 : 0 : if (sk->sk_state != TCP_CLOSE) {
3063 : : err = -EINVAL;
3064 : : break;
3065 : : }
3066 : 0 : tp->window_clamp = 0;
3067 : : } else
3068 : 0 : tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
3069 : 0 : SOCK_MIN_RCVBUF / 2 : val;
3070 : : break;
3071 : :
3072 : : case TCP_QUICKACK:
3073 : 0 : if (!val) {
3074 : : inet_csk_enter_pingpong_mode(sk);
3075 : : } else {
3076 : : inet_csk_exit_pingpong_mode(sk);
3077 : 0 : if ((1 << sk->sk_state) &
3078 : 0 : (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
3079 : : inet_csk_ack_scheduled(sk)) {
3080 : 0 : icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
3081 : 0 : tcp_cleanup_rbuf(sk, 1);
3082 : 0 : if (!(val & 1))
3083 : : inet_csk_enter_pingpong_mode(sk);
3084 : : }
3085 : : }
3086 : : break;
3087 : :
3088 : : #ifdef CONFIG_TCP_MD5SIG
3089 : : case TCP_MD5SIG:
3090 : : case TCP_MD5SIG_EXT:
3091 : : err = tp->af_specific->md5_parse(sk, optname, optval, optlen);
3092 : : break;
3093 : : #endif
3094 : : case TCP_USER_TIMEOUT:
3095 : : /* Cap the max time in ms TCP will retry or probe the window
3096 : : * before giving up and aborting (ETIMEDOUT) a connection.
3097 : : */
3098 : 0 : if (val < 0)
3099 : : err = -EINVAL;
3100 : : else
3101 : 0 : icsk->icsk_user_timeout = val;
3102 : : break;
3103 : :
3104 : : case TCP_FASTOPEN:
3105 : 0 : if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE |
3106 : : TCPF_LISTEN))) {
3107 : 0 : tcp_fastopen_init_key_once(net);
3108 : :
3109 : : fastopen_queue_tune(sk, val);
3110 : : } else {
3111 : : err = -EINVAL;
3112 : : }
3113 : : break;
3114 : : case TCP_FASTOPEN_CONNECT:
3115 : 0 : if (val > 1 || val < 0) {
3116 : : err = -EINVAL;
3117 : 0 : } else if (net->ipv4.sysctl_tcp_fastopen & TFO_CLIENT_ENABLE) {
3118 : 0 : if (sk->sk_state == TCP_CLOSE)
3119 : 0 : tp->fastopen_connect = val;
3120 : : else
3121 : : err = -EINVAL;
3122 : : } else {
3123 : : err = -EOPNOTSUPP;
3124 : : }
3125 : : break;
3126 : : case TCP_FASTOPEN_NO_COOKIE:
3127 : 0 : if (val > 1 || val < 0)
3128 : : err = -EINVAL;
3129 : 0 : else if (!((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
3130 : : err = -EINVAL;
3131 : : else
3132 : 0 : tp->fastopen_no_cookie = val;
3133 : : break;
3134 : : case TCP_TIMESTAMP:
3135 : 0 : if (!tp->repair)
3136 : : err = -EPERM;
3137 : : else
3138 : 0 : tp->tsoffset = val - tcp_time_stamp_raw();
3139 : : break;
3140 : : case TCP_REPAIR_WINDOW:
3141 : 0 : err = tcp_repair_set_window(tp, optval, optlen);
3142 : 0 : break;
3143 : : case TCP_NOTSENT_LOWAT:
3144 : 0 : tp->notsent_lowat = val;
3145 : 0 : sk->sk_write_space(sk);
3146 : 0 : break;
3147 : : case TCP_INQ:
3148 : 0 : if (val > 1 || val < 0)
3149 : : err = -EINVAL;
3150 : : else
3151 : 0 : tp->recvmsg_inq = val;
3152 : : break;
3153 : : case TCP_TX_DELAY:
3154 : 0 : if (val)
3155 : 0 : tcp_enable_tx_delay();
3156 : 0 : tp->tcp_tx_delay = val;
3157 : 0 : break;
3158 : : default:
3159 : : err = -ENOPROTOOPT;
3160 : : break;
3161 : : }
3162 : :
3163 : 1 : release_sock(sk);
3164 : 1 : return err;
3165 : : }
3166 : :
3167 : 1 : int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
3168 : : unsigned int optlen)
3169 : : {
3170 : : const struct inet_connection_sock *icsk = inet_csk(sk);
3171 : :
3172 : 1 : if (level != SOL_TCP)
3173 : 0 : return icsk->icsk_af_ops->setsockopt(sk, level, optname,
3174 : : optval, optlen);
3175 : 1 : return do_tcp_setsockopt(sk, level, optname, optval, optlen);
3176 : : }
3177 : : EXPORT_SYMBOL(tcp_setsockopt);
3178 : :
3179 : : #ifdef CONFIG_COMPAT
3180 : : int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
3181 : : char __user *optval, unsigned int optlen)
3182 : : {
3183 : : if (level != SOL_TCP)
3184 : : return inet_csk_compat_setsockopt(sk, level, optname,
3185 : : optval, optlen);
3186 : : return do_tcp_setsockopt(sk, level, optname, optval, optlen);
3187 : : }
3188 : : EXPORT_SYMBOL(compat_tcp_setsockopt);
3189 : : #endif
3190 : :
3191 : 1 : static void tcp_get_info_chrono_stats(const struct tcp_sock *tp,
3192 : : struct tcp_info *info)
3193 : : {
3194 : : u64 stats[__TCP_CHRONO_MAX], total = 0;
3195 : : enum tcp_chrono i;
3196 : :
3197 : 1 : for (i = TCP_CHRONO_BUSY; i < __TCP_CHRONO_MAX; ++i) {
3198 : 1 : stats[i] = tp->chrono_stat[i - 1];
3199 : 1 : if (i == tp->chrono_type)
3200 : 1 : stats[i] += tcp_jiffies32 - tp->chrono_start;
3201 : 1 : stats[i] *= USEC_PER_SEC / HZ;
3202 : 1 : total += stats[i];
3203 : : }
3204 : :
3205 : 1 : info->tcpi_busy_time = total;
3206 : 1 : info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED];
3207 : 1 : info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED];
3208 : 1 : }
3209 : :
3210 : : /* Return information about state of tcp endpoint in API format. */
3211 : 1 : void tcp_get_info(struct sock *sk, struct tcp_info *info)
3212 : : {
3213 : : const struct tcp_sock *tp = tcp_sk(sk); /* iff sk_type == SOCK_STREAM */
3214 : : const struct inet_connection_sock *icsk = inet_csk(sk);
3215 : : unsigned long rate;
3216 : : u32 now;
3217 : : u64 rate64;
3218 : : bool slow;
3219 : :
3220 : 1 : memset(info, 0, sizeof(*info));
3221 : 1 : if (sk->sk_type != SOCK_STREAM)
3222 : : return;
3223 : :
3224 : 1 : info->tcpi_state = inet_sk_state_load(sk);
3225 : :
3226 : : /* Report meaningful fields for all TCP states, including listeners */
3227 : : rate = READ_ONCE(sk->sk_pacing_rate);
3228 : 1 : rate64 = (rate != ~0UL) ? rate : ~0ULL;
3229 : 1 : info->tcpi_pacing_rate = rate64;
3230 : :
3231 : : rate = READ_ONCE(sk->sk_max_pacing_rate);
3232 : 1 : rate64 = (rate != ~0UL) ? rate : ~0ULL;
3233 : 1 : info->tcpi_max_pacing_rate = rate64;
3234 : :
3235 : 1 : info->tcpi_reordering = tp->reordering;
3236 : 1 : info->tcpi_snd_cwnd = tp->snd_cwnd;
3237 : :
3238 : 1 : if (info->tcpi_state == TCP_LISTEN) {
3239 : : /* listeners aliased fields :
3240 : : * tcpi_unacked -> Number of children ready for accept()
3241 : : * tcpi_sacked -> max backlog
3242 : : */
3243 : 0 : info->tcpi_unacked = sk->sk_ack_backlog;
3244 : 0 : info->tcpi_sacked = sk->sk_max_ack_backlog;
3245 : 0 : return;
3246 : : }
3247 : :
3248 : 1 : slow = lock_sock_fast(sk);
3249 : :
3250 : 1 : info->tcpi_ca_state = icsk->icsk_ca_state;
3251 : 1 : info->tcpi_retransmits = icsk->icsk_retransmits;
3252 : 1 : info->tcpi_probes = icsk->icsk_probes_out;
3253 : 1 : info->tcpi_backoff = icsk->icsk_backoff;
3254 : :
3255 : 1 : if (tp->rx_opt.tstamp_ok)
3256 : 0 : info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
3257 : 1 : if (tcp_is_sack(tp))
3258 : 0 : info->tcpi_options |= TCPI_OPT_SACK;
3259 : 1 : if (tp->rx_opt.wscale_ok) {
3260 : 0 : info->tcpi_options |= TCPI_OPT_WSCALE;
3261 : 0 : info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
3262 : 0 : info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
3263 : : }
3264 : :
3265 : 1 : if (tp->ecn_flags & TCP_ECN_OK)
3266 : 0 : info->tcpi_options |= TCPI_OPT_ECN;
3267 : 1 : if (tp->ecn_flags & TCP_ECN_SEEN)
3268 : 0 : info->tcpi_options |= TCPI_OPT_ECN_SEEN;
3269 : 1 : if (tp->syn_data_acked)
3270 : 0 : info->tcpi_options |= TCPI_OPT_SYN_DATA;
3271 : :
3272 : 1 : info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto);
3273 : 1 : info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato);
3274 : 1 : info->tcpi_snd_mss = tp->mss_cache;
3275 : 1 : info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss;
3276 : :
3277 : 1 : info->tcpi_unacked = tp->packets_out;
3278 : 1 : info->tcpi_sacked = tp->sacked_out;
3279 : :
3280 : 1 : info->tcpi_lost = tp->lost_out;
3281 : 1 : info->tcpi_retrans = tp->retrans_out;
3282 : :
3283 : 1 : now = tcp_jiffies32;
3284 : 1 : info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
3285 : 1 : info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime);
3286 : 1 : info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
3287 : :
3288 : 1 : info->tcpi_pmtu = icsk->icsk_pmtu_cookie;
3289 : 1 : info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
3290 : 1 : info->tcpi_rtt = tp->srtt_us >> 3;
3291 : 1 : info->tcpi_rttvar = tp->mdev_us >> 2;
3292 : 1 : info->tcpi_snd_ssthresh = tp->snd_ssthresh;
3293 : 1 : info->tcpi_advmss = tp->advmss;
3294 : :
3295 : 1 : info->tcpi_rcv_rtt = tp->rcv_rtt_est.rtt_us >> 3;
3296 : 1 : info->tcpi_rcv_space = tp->rcvq_space.space;
3297 : :
3298 : 1 : info->tcpi_total_retrans = tp->total_retrans;
3299 : :
3300 : 1 : info->tcpi_bytes_acked = tp->bytes_acked;
3301 : 1 : info->tcpi_bytes_received = tp->bytes_received;
3302 : 1 : info->tcpi_notsent_bytes = max_t(int, 0, tp->write_seq - tp->snd_nxt);
3303 : 1 : tcp_get_info_chrono_stats(tp, info);
3304 : :
3305 : 1 : info->tcpi_segs_out = tp->segs_out;
3306 : 1 : info->tcpi_segs_in = tp->segs_in;
3307 : :
3308 : 1 : info->tcpi_min_rtt = tcp_min_rtt(tp);
3309 : 1 : info->tcpi_data_segs_in = tp->data_segs_in;
3310 : 1 : info->tcpi_data_segs_out = tp->data_segs_out;
3311 : :
3312 : 1 : info->tcpi_delivery_rate_app_limited = tp->rate_app_limited ? 1 : 0;
3313 : 1 : rate64 = tcp_compute_delivery_rate(tp);
3314 : 1 : if (rate64)
3315 : 1 : info->tcpi_delivery_rate = rate64;
3316 : 1 : info->tcpi_delivered = tp->delivered;
3317 : 1 : info->tcpi_delivered_ce = tp->delivered_ce;
3318 : 1 : info->tcpi_bytes_sent = tp->bytes_sent;
3319 : 1 : info->tcpi_bytes_retrans = tp->bytes_retrans;
3320 : 1 : info->tcpi_dsack_dups = tp->dsack_dups;
3321 : 1 : info->tcpi_reord_seen = tp->reord_seen;
3322 : 1 : info->tcpi_rcv_ooopack = tp->rcv_ooopack;
3323 : 1 : info->tcpi_snd_wnd = tp->snd_wnd;
3324 : : unlock_sock_fast(sk, slow);
3325 : : }
3326 : : EXPORT_SYMBOL_GPL(tcp_get_info);
3327 : :
3328 : : static size_t tcp_opt_stats_get_size(void)
3329 : : {
3330 : : return
3331 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BUSY */
3332 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_RWND_LIMITED */
3333 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_SNDBUF_LIMITED */
3334 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DATA_SEGS_OUT */
3335 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_TOTAL_RETRANS */
3336 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_PACING_RATE */
3337 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DELIVERY_RATE */
3338 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_CWND */
3339 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_REORDERING */
3340 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_MIN_RTT */
3341 : : nla_total_size(sizeof(u8)) + /* TCP_NLA_RECUR_RETRANS */
3342 : : nla_total_size(sizeof(u8)) + /* TCP_NLA_DELIVERY_RATE_APP_LMT */
3343 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_SNDQ_SIZE */
3344 : : nla_total_size(sizeof(u8)) + /* TCP_NLA_CA_STATE */
3345 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_SSTHRESH */
3346 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED */
3347 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED_CE */
3348 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_SENT */
3349 : : nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_RETRANS */
3350 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_DSACK_DUPS */
3351 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_REORD_SEEN */
3352 : : nla_total_size(sizeof(u32)) + /* TCP_NLA_SRTT */
3353 : : 0;
3354 : : }
3355 : :
3356 : 0 : struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk)
3357 : : {
3358 : : const struct tcp_sock *tp = tcp_sk(sk);
3359 : : struct sk_buff *stats;
3360 : : struct tcp_info info;
3361 : : unsigned long rate;
3362 : : u64 rate64;
3363 : :
3364 : : stats = alloc_skb(tcp_opt_stats_get_size(), GFP_ATOMIC);
3365 : 0 : if (!stats)
3366 : : return NULL;
3367 : :
3368 : 0 : tcp_get_info_chrono_stats(tp, &info);
3369 : 0 : nla_put_u64_64bit(stats, TCP_NLA_BUSY,
3370 : : info.tcpi_busy_time, TCP_NLA_PAD);
3371 : 0 : nla_put_u64_64bit(stats, TCP_NLA_RWND_LIMITED,
3372 : : info.tcpi_rwnd_limited, TCP_NLA_PAD);
3373 : 0 : nla_put_u64_64bit(stats, TCP_NLA_SNDBUF_LIMITED,
3374 : : info.tcpi_sndbuf_limited, TCP_NLA_PAD);
3375 : 0 : nla_put_u64_64bit(stats, TCP_NLA_DATA_SEGS_OUT,
3376 : 0 : tp->data_segs_out, TCP_NLA_PAD);
3377 : 0 : nla_put_u64_64bit(stats, TCP_NLA_TOTAL_RETRANS,
3378 : 0 : tp->total_retrans, TCP_NLA_PAD);
3379 : :
3380 : : rate = READ_ONCE(sk->sk_pacing_rate);
3381 : 0 : rate64 = (rate != ~0UL) ? rate : ~0ULL;
3382 : : nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD);
3383 : :
3384 : 0 : rate64 = tcp_compute_delivery_rate(tp);
3385 : : nla_put_u64_64bit(stats, TCP_NLA_DELIVERY_RATE, rate64, TCP_NLA_PAD);
3386 : :
3387 : 0 : nla_put_u32(stats, TCP_NLA_SND_CWND, tp->snd_cwnd);
3388 : 0 : nla_put_u32(stats, TCP_NLA_REORDERING, tp->reordering);
3389 : : nla_put_u32(stats, TCP_NLA_MIN_RTT, tcp_min_rtt(tp));
3390 : :
3391 : 0 : nla_put_u8(stats, TCP_NLA_RECUR_RETRANS, inet_csk(sk)->icsk_retransmits);
3392 : 0 : nla_put_u8(stats, TCP_NLA_DELIVERY_RATE_APP_LMT, !!tp->rate_app_limited);
3393 : 0 : nla_put_u32(stats, TCP_NLA_SND_SSTHRESH, tp->snd_ssthresh);
3394 : 0 : nla_put_u32(stats, TCP_NLA_DELIVERED, tp->delivered);
3395 : 0 : nla_put_u32(stats, TCP_NLA_DELIVERED_CE, tp->delivered_ce);
3396 : :
3397 : 0 : nla_put_u32(stats, TCP_NLA_SNDQ_SIZE, tp->write_seq - tp->snd_una);
3398 : 0 : nla_put_u8(stats, TCP_NLA_CA_STATE, inet_csk(sk)->icsk_ca_state);
3399 : :
3400 : 0 : nla_put_u64_64bit(stats, TCP_NLA_BYTES_SENT, tp->bytes_sent,
3401 : : TCP_NLA_PAD);
3402 : 0 : nla_put_u64_64bit(stats, TCP_NLA_BYTES_RETRANS, tp->bytes_retrans,
3403 : : TCP_NLA_PAD);
3404 : 0 : nla_put_u32(stats, TCP_NLA_DSACK_DUPS, tp->dsack_dups);
3405 : 0 : nla_put_u32(stats, TCP_NLA_REORD_SEEN, tp->reord_seen);
3406 : 0 : nla_put_u32(stats, TCP_NLA_SRTT, tp->srtt_us >> 3);
3407 : :
3408 : 0 : return stats;
3409 : : }
3410 : :
3411 : 1 : static int do_tcp_getsockopt(struct sock *sk, int level,
3412 : : int optname, char __user *optval, int __user *optlen)
3413 : : {
3414 : : struct inet_connection_sock *icsk = inet_csk(sk);
3415 : : struct tcp_sock *tp = tcp_sk(sk);
3416 : : struct net *net = sock_net(sk);
3417 : : int val, len;
3418 : :
3419 : 1 : if (get_user(len, optlen))
3420 : : return -EFAULT;
3421 : :
3422 : 1 : len = min_t(unsigned int, len, sizeof(int));
3423 : :
3424 : 1 : if (len < 0)
3425 : : return -EINVAL;
3426 : :
3427 : 1 : switch (optname) {
3428 : : case TCP_MAXSEG:
3429 : 0 : val = tp->mss_cache;
3430 : 0 : if (!val && ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
3431 : 0 : val = tp->rx_opt.user_mss;
3432 : 0 : if (tp->repair)
3433 : 0 : val = tp->rx_opt.mss_clamp;
3434 : : break;
3435 : : case TCP_NODELAY:
3436 : 0 : val = !!(tp->nonagle&TCP_NAGLE_OFF);
3437 : 0 : break;
3438 : : case TCP_CORK:
3439 : 0 : val = !!(tp->nonagle&TCP_NAGLE_CORK);
3440 : 0 : break;
3441 : : case TCP_KEEPIDLE:
3442 : 0 : val = keepalive_time_when(tp) / HZ;
3443 : 0 : break;
3444 : : case TCP_KEEPINTVL:
3445 : 0 : val = keepalive_intvl_when(tp) / HZ;
3446 : 0 : break;
3447 : : case TCP_KEEPCNT:
3448 : 0 : val = keepalive_probes(tp);
3449 : 0 : break;
3450 : : case TCP_SYNCNT:
3451 : 0 : val = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries;
3452 : 0 : break;
3453 : : case TCP_LINGER2:
3454 : 0 : val = tp->linger2;
3455 : 0 : if (val >= 0)
3456 : 0 : val = (val ? : net->ipv4.sysctl_tcp_fin_timeout) / HZ;
3457 : : break;
3458 : : case TCP_DEFER_ACCEPT:
3459 : 0 : val = retrans_to_secs(icsk->icsk_accept_queue.rskq_defer_accept,
3460 : : TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
3461 : 0 : break;
3462 : : case TCP_WINDOW_CLAMP:
3463 : 0 : val = tp->window_clamp;
3464 : 0 : break;
3465 : : case TCP_INFO: {
3466 : : struct tcp_info info;
3467 : :
3468 : 1 : if (get_user(len, optlen))
3469 : : return -EFAULT;
3470 : :
3471 : 1 : tcp_get_info(sk, &info);
3472 : :
3473 : 1 : len = min_t(unsigned int, len, sizeof(info));
3474 : 1 : if (put_user(len, optlen))
3475 : : return -EFAULT;
3476 : 1 : if (copy_to_user(optval, &info, len))
3477 : : return -EFAULT;
3478 : 1 : return 0;
3479 : : }
3480 : : case TCP_CC_INFO: {
3481 : : const struct tcp_congestion_ops *ca_ops;
3482 : : union tcp_cc_info info;
3483 : : size_t sz = 0;
3484 : : int attr;
3485 : :
3486 : 0 : if (get_user(len, optlen))
3487 : : return -EFAULT;
3488 : :
3489 : 0 : ca_ops = icsk->icsk_ca_ops;
3490 : 0 : if (ca_ops && ca_ops->get_info)
3491 : 0 : sz = ca_ops->get_info(sk, ~0U, &attr, &info);
3492 : :
3493 : 0 : len = min_t(unsigned int, len, sz);
3494 : 0 : if (put_user(len, optlen))
3495 : : return -EFAULT;
3496 : 0 : if (copy_to_user(optval, &info, len))
3497 : : return -EFAULT;
3498 : 0 : return 0;
3499 : : }
3500 : : case TCP_QUICKACK:
3501 : 0 : val = !inet_csk_in_pingpong_mode(sk);
3502 : 0 : break;
3503 : :
3504 : : case TCP_CONGESTION:
3505 : 0 : if (get_user(len, optlen))
3506 : : return -EFAULT;
3507 : 0 : len = min_t(unsigned int, len, TCP_CA_NAME_MAX);
3508 : 0 : if (put_user(len, optlen))
3509 : : return -EFAULT;
3510 : 0 : if (copy_to_user(optval, icsk->icsk_ca_ops->name, len))
3511 : : return -EFAULT;
3512 : 0 : return 0;
3513 : :
3514 : : case TCP_ULP:
3515 : 0 : if (get_user(len, optlen))
3516 : : return -EFAULT;
3517 : 0 : len = min_t(unsigned int, len, TCP_ULP_NAME_MAX);
3518 : 0 : if (!icsk->icsk_ulp_ops) {
3519 : 0 : if (put_user(0, optlen))
3520 : : return -EFAULT;
3521 : 0 : return 0;
3522 : : }
3523 : 0 : if (put_user(len, optlen))
3524 : : return -EFAULT;
3525 : 0 : if (copy_to_user(optval, icsk->icsk_ulp_ops->name, len))
3526 : : return -EFAULT;
3527 : 0 : return 0;
3528 : :
3529 : : case TCP_FASTOPEN_KEY: {
3530 : : u64 key[TCP_FASTOPEN_KEY_BUF_LENGTH / sizeof(u64)];
3531 : : unsigned int key_len;
3532 : :
3533 : 0 : if (get_user(len, optlen))
3534 : : return -EFAULT;
3535 : :
3536 : 0 : key_len = tcp_fastopen_get_cipher(net, icsk, key) *
3537 : : TCP_FASTOPEN_KEY_LENGTH;
3538 : 0 : len = min_t(unsigned int, len, key_len);
3539 : 0 : if (put_user(len, optlen))
3540 : : return -EFAULT;
3541 : 0 : if (copy_to_user(optval, key, len))
3542 : : return -EFAULT;
3543 : 0 : return 0;
3544 : : }
3545 : : case TCP_THIN_LINEAR_TIMEOUTS:
3546 : 0 : val = tp->thin_lto;
3547 : 0 : break;
3548 : :
3549 : : case TCP_THIN_DUPACK:
3550 : 0 : val = 0;
3551 : 0 : break;
3552 : :
3553 : : case TCP_REPAIR:
3554 : 0 : val = tp->repair;
3555 : 0 : break;
3556 : :
3557 : : case TCP_REPAIR_QUEUE:
3558 : 0 : if (tp->repair)
3559 : 0 : val = tp->repair_queue;
3560 : : else
3561 : : return -EINVAL;
3562 : 0 : break;
3563 : :
3564 : : case TCP_REPAIR_WINDOW: {
3565 : : struct tcp_repair_window opt;
3566 : :
3567 : 0 : if (get_user(len, optlen))
3568 : : return -EFAULT;
3569 : :
3570 : 0 : if (len != sizeof(opt))
3571 : : return -EINVAL;
3572 : :
3573 : 0 : if (!tp->repair)
3574 : : return -EPERM;
3575 : :
3576 : 0 : opt.snd_wl1 = tp->snd_wl1;
3577 : 0 : opt.snd_wnd = tp->snd_wnd;
3578 : 0 : opt.max_window = tp->max_window;
3579 : 0 : opt.rcv_wnd = tp->rcv_wnd;
3580 : 0 : opt.rcv_wup = tp->rcv_wup;
3581 : :
3582 : 0 : if (copy_to_user(optval, &opt, len))
3583 : : return -EFAULT;
3584 : 0 : return 0;
3585 : : }
3586 : : case TCP_QUEUE_SEQ:
3587 : 0 : if (tp->repair_queue == TCP_SEND_QUEUE)
3588 : 0 : val = tp->write_seq;
3589 : 0 : else if (tp->repair_queue == TCP_RECV_QUEUE)
3590 : 0 : val = tp->rcv_nxt;
3591 : : else
3592 : : return -EINVAL;
3593 : : break;
3594 : :
3595 : : case TCP_USER_TIMEOUT:
3596 : 0 : val = icsk->icsk_user_timeout;
3597 : 0 : break;
3598 : :
3599 : : case TCP_FASTOPEN:
3600 : 0 : val = icsk->icsk_accept_queue.fastopenq.max_qlen;
3601 : 0 : break;
3602 : :
3603 : : case TCP_FASTOPEN_CONNECT:
3604 : 0 : val = tp->fastopen_connect;
3605 : 0 : break;
3606 : :
3607 : : case TCP_FASTOPEN_NO_COOKIE:
3608 : 0 : val = tp->fastopen_no_cookie;
3609 : 0 : break;
3610 : :
3611 : : case TCP_TX_DELAY:
3612 : 0 : val = tp->tcp_tx_delay;
3613 : 0 : break;
3614 : :
3615 : : case TCP_TIMESTAMP:
3616 : 0 : val = tcp_time_stamp_raw() + tp->tsoffset;
3617 : 0 : break;
3618 : : case TCP_NOTSENT_LOWAT:
3619 : 0 : val = tp->notsent_lowat;
3620 : 0 : break;
3621 : : case TCP_INQ:
3622 : 0 : val = tp->recvmsg_inq;
3623 : 0 : break;
3624 : : case TCP_SAVE_SYN:
3625 : 0 : val = tp->save_syn;
3626 : 0 : break;
3627 : : case TCP_SAVED_SYN: {
3628 : 0 : if (get_user(len, optlen))
3629 : : return -EFAULT;
3630 : :
3631 : : lock_sock(sk);
3632 : 0 : if (tp->saved_syn) {
3633 : 0 : if (len < tp->saved_syn[0]) {
3634 : 0 : if (put_user(tp->saved_syn[0], optlen)) {
3635 : 0 : release_sock(sk);
3636 : 0 : return -EFAULT;
3637 : : }
3638 : 0 : release_sock(sk);
3639 : 0 : return -EINVAL;
3640 : : }
3641 : 0 : len = tp->saved_syn[0];
3642 : 0 : if (put_user(len, optlen)) {
3643 : 0 : release_sock(sk);
3644 : 0 : return -EFAULT;
3645 : : }
3646 : 0 : if (copy_to_user(optval, tp->saved_syn + 1, len)) {
3647 : 0 : release_sock(sk);
3648 : 0 : return -EFAULT;
3649 : : }
3650 : : tcp_saved_syn_free(tp);
3651 : 0 : release_sock(sk);
3652 : : } else {
3653 : 0 : release_sock(sk);
3654 : : len = 0;
3655 : 0 : if (put_user(len, optlen))
3656 : : return -EFAULT;
3657 : : }
3658 : : return 0;
3659 : : }
3660 : : #ifdef CONFIG_MMU
3661 : : case TCP_ZEROCOPY_RECEIVE: {
3662 : : struct tcp_zerocopy_receive zc;
3663 : : int err;
3664 : :
3665 : 0 : if (get_user(len, optlen))
3666 : : return -EFAULT;
3667 : 0 : if (len != sizeof(zc))
3668 : : return -EINVAL;
3669 : 0 : if (copy_from_user(&zc, optval, len))
3670 : : return -EFAULT;
3671 : : lock_sock(sk);
3672 : 0 : err = tcp_zerocopy_receive(sk, &zc);
3673 : 0 : release_sock(sk);
3674 : 0 : if (!err && copy_to_user(optval, &zc, len))
3675 : : err = -EFAULT;
3676 : 0 : return err;
3677 : : }
3678 : : #endif
3679 : : default:
3680 : : return -ENOPROTOOPT;
3681 : : }
3682 : :
3683 : 0 : if (put_user(len, optlen))
3684 : : return -EFAULT;
3685 : 0 : if (copy_to_user(optval, &val, len))
3686 : : return -EFAULT;
3687 : 0 : return 0;
3688 : : }
3689 : :
3690 : 1 : int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
3691 : : int __user *optlen)
3692 : : {
3693 : : struct inet_connection_sock *icsk = inet_csk(sk);
3694 : :
3695 : 1 : if (level != SOL_TCP)
3696 : 0 : return icsk->icsk_af_ops->getsockopt(sk, level, optname,
3697 : : optval, optlen);
3698 : 1 : return do_tcp_getsockopt(sk, level, optname, optval, optlen);
3699 : : }
3700 : : EXPORT_SYMBOL(tcp_getsockopt);
3701 : :
3702 : : #ifdef CONFIG_COMPAT
3703 : : int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
3704 : : char __user *optval, int __user *optlen)
3705 : : {
3706 : : if (level != SOL_TCP)
3707 : : return inet_csk_compat_getsockopt(sk, level, optname,
3708 : : optval, optlen);
3709 : : return do_tcp_getsockopt(sk, level, optname, optval, optlen);
3710 : : }
3711 : : EXPORT_SYMBOL(compat_tcp_getsockopt);
3712 : : #endif
3713 : :
3714 : : #ifdef CONFIG_TCP_MD5SIG
3715 : : static DEFINE_PER_CPU(struct tcp_md5sig_pool, tcp_md5sig_pool);
3716 : : static DEFINE_MUTEX(tcp_md5sig_mutex);
3717 : : static bool tcp_md5sig_pool_populated = false;
3718 : :
3719 : : static void __tcp_alloc_md5sig_pool(void)
3720 : : {
3721 : : struct crypto_ahash *hash;
3722 : : int cpu;
3723 : :
3724 : : hash = crypto_alloc_ahash("md5", 0, CRYPTO_ALG_ASYNC);
3725 : : if (IS_ERR(hash))
3726 : : return;
3727 : :
3728 : : for_each_possible_cpu(cpu) {
3729 : : void *scratch = per_cpu(tcp_md5sig_pool, cpu).scratch;
3730 : : struct ahash_request *req;
3731 : :
3732 : : if (!scratch) {
3733 : : scratch = kmalloc_node(sizeof(union tcp_md5sum_block) +
3734 : : sizeof(struct tcphdr),
3735 : : GFP_KERNEL,
3736 : : cpu_to_node(cpu));
3737 : : if (!scratch)
3738 : : return;
3739 : : per_cpu(tcp_md5sig_pool, cpu).scratch = scratch;
3740 : : }
3741 : : if (per_cpu(tcp_md5sig_pool, cpu).md5_req)
3742 : : continue;
3743 : :
3744 : : req = ahash_request_alloc(hash, GFP_KERNEL);
3745 : : if (!req)
3746 : : return;
3747 : :
3748 : : ahash_request_set_callback(req, 0, NULL, NULL);
3749 : :
3750 : : per_cpu(tcp_md5sig_pool, cpu).md5_req = req;
3751 : : }
3752 : : /* before setting tcp_md5sig_pool_populated, we must commit all writes
3753 : : * to memory. See smp_rmb() in tcp_get_md5sig_pool()
3754 : : */
3755 : : smp_wmb();
3756 : : tcp_md5sig_pool_populated = true;
3757 : : }
3758 : :
3759 : : bool tcp_alloc_md5sig_pool(void)
3760 : : {
3761 : : if (unlikely(!tcp_md5sig_pool_populated)) {
3762 : : mutex_lock(&tcp_md5sig_mutex);
3763 : :
3764 : : if (!tcp_md5sig_pool_populated) {
3765 : : __tcp_alloc_md5sig_pool();
3766 : : if (tcp_md5sig_pool_populated)
3767 : : static_branch_inc(&tcp_md5_needed);
3768 : : }
3769 : :
3770 : : mutex_unlock(&tcp_md5sig_mutex);
3771 : : }
3772 : : return tcp_md5sig_pool_populated;
3773 : : }
3774 : : EXPORT_SYMBOL(tcp_alloc_md5sig_pool);
3775 : :
3776 : :
3777 : : /**
3778 : : * tcp_get_md5sig_pool - get md5sig_pool for this user
3779 : : *
3780 : : * We use percpu structure, so if we succeed, we exit with preemption
3781 : : * and BH disabled, to make sure another thread or softirq handling
3782 : : * wont try to get same context.
3783 : : */
3784 : : struct tcp_md5sig_pool *tcp_get_md5sig_pool(void)
3785 : : {
3786 : : local_bh_disable();
3787 : :
3788 : : if (tcp_md5sig_pool_populated) {
3789 : : /* coupled with smp_wmb() in __tcp_alloc_md5sig_pool() */
3790 : : smp_rmb();
3791 : : return this_cpu_ptr(&tcp_md5sig_pool);
3792 : : }
3793 : : local_bh_enable();
3794 : : return NULL;
3795 : : }
3796 : : EXPORT_SYMBOL(tcp_get_md5sig_pool);
3797 : :
3798 : : int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *hp,
3799 : : const struct sk_buff *skb, unsigned int header_len)
3800 : : {
3801 : : struct scatterlist sg;
3802 : : const struct tcphdr *tp = tcp_hdr(skb);
3803 : : struct ahash_request *req = hp->md5_req;
3804 : : unsigned int i;
3805 : : const unsigned int head_data_len = skb_headlen(skb) > header_len ?
3806 : : skb_headlen(skb) - header_len : 0;
3807 : : const struct skb_shared_info *shi = skb_shinfo(skb);
3808 : : struct sk_buff *frag_iter;
3809 : :
3810 : : sg_init_table(&sg, 1);
3811 : :
3812 : : sg_set_buf(&sg, ((u8 *) tp) + header_len, head_data_len);
3813 : : ahash_request_set_crypt(req, &sg, NULL, head_data_len);
3814 : : if (crypto_ahash_update(req))
3815 : : return 1;
3816 : :
3817 : : for (i = 0; i < shi->nr_frags; ++i) {
3818 : : const skb_frag_t *f = &shi->frags[i];
3819 : : unsigned int offset = skb_frag_off(f);
3820 : : struct page *page = skb_frag_page(f) + (offset >> PAGE_SHIFT);
3821 : :
3822 : : sg_set_page(&sg, page, skb_frag_size(f),
3823 : : offset_in_page(offset));
3824 : : ahash_request_set_crypt(req, &sg, NULL, skb_frag_size(f));
3825 : : if (crypto_ahash_update(req))
3826 : : return 1;
3827 : : }
3828 : :
3829 : : skb_walk_frags(skb, frag_iter)
3830 : : if (tcp_md5_hash_skb_data(hp, frag_iter, 0))
3831 : : return 1;
3832 : :
3833 : : return 0;
3834 : : }
3835 : : EXPORT_SYMBOL(tcp_md5_hash_skb_data);
3836 : :
3837 : : int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, const struct tcp_md5sig_key *key)
3838 : : {
3839 : : u8 keylen = READ_ONCE(key->keylen); /* paired with WRITE_ONCE() in tcp_md5_do_add */
3840 : : struct scatterlist sg;
3841 : :
3842 : : sg_init_one(&sg, key->key, keylen);
3843 : : ahash_request_set_crypt(hp->md5_req, &sg, NULL, keylen);
3844 : :
3845 : : /* tcp_md5_do_add() might change key->key under us */
3846 : : return crypto_ahash_update(hp->md5_req);
3847 : : }
3848 : : EXPORT_SYMBOL(tcp_md5_hash_key);
3849 : :
3850 : : #endif
3851 : :
3852 : 1 : void tcp_done(struct sock *sk)
3853 : : {
3854 : : struct request_sock *req;
3855 : :
3856 : : /* We might be called with a new socket, after
3857 : : * inet_csk_prepare_forced_close() has been called
3858 : : * so we can not use lockdep_sock_is_held(sk)
3859 : : */
3860 : 1 : req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk, 1);
3861 : :
3862 : 1 : if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
3863 : 0 : TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
3864 : :
3865 : 1 : tcp_set_state(sk, TCP_CLOSE);
3866 : 1 : tcp_clear_xmit_timers(sk);
3867 : 1 : if (req)
3868 : 0 : reqsk_fastopen_remove(sk, req, false);
3869 : :
3870 : 1 : sk->sk_shutdown = SHUTDOWN_MASK;
3871 : :
3872 : 1 : if (!sock_flag(sk, SOCK_DEAD))
3873 : 0 : sk->sk_state_change(sk);
3874 : : else
3875 : 1 : inet_csk_destroy_sock(sk);
3876 : 1 : }
3877 : : EXPORT_SYMBOL_GPL(tcp_done);
3878 : :
3879 : 0 : int tcp_abort(struct sock *sk, int err)
3880 : : {
3881 : 0 : if (!sk_fullsock(sk)) {
3882 : 0 : if (sk->sk_state == TCP_NEW_SYN_RECV) {
3883 : : struct request_sock *req = inet_reqsk(sk);
3884 : :
3885 : : local_bh_disable();
3886 : 0 : inet_csk_reqsk_queue_drop(req->rsk_listener, req);
3887 : : local_bh_enable();
3888 : 0 : return 0;
3889 : : }
3890 : : return -EOPNOTSUPP;
3891 : : }
3892 : :
3893 : : /* Don't race with userspace socket closes such as tcp_close. */
3894 : : lock_sock(sk);
3895 : :
3896 : 0 : if (sk->sk_state == TCP_LISTEN) {
3897 : 0 : tcp_set_state(sk, TCP_CLOSE);
3898 : 0 : inet_csk_listen_stop(sk);
3899 : : }
3900 : :
3901 : : /* Don't race with BH socket closes such as inet_csk_listen_stop. */
3902 : : local_bh_disable();
3903 : : bh_lock_sock(sk);
3904 : :
3905 : 0 : if (!sock_flag(sk, SOCK_DEAD)) {
3906 : 0 : sk->sk_err = err;
3907 : : /* This barrier is coupled with smp_rmb() in tcp_poll() */
3908 : 0 : smp_wmb();
3909 : 0 : sk->sk_error_report(sk);
3910 : 0 : if (tcp_need_reset(sk->sk_state))
3911 : 0 : tcp_send_active_reset(sk, GFP_ATOMIC);
3912 : 0 : tcp_done(sk);
3913 : : }
3914 : :
3915 : : bh_unlock_sock(sk);
3916 : : local_bh_enable();
3917 : 0 : tcp_write_queue_purge(sk);
3918 : 0 : release_sock(sk);
3919 : 0 : return 0;
3920 : : }
3921 : : EXPORT_SYMBOL_GPL(tcp_abort);
3922 : :
3923 : : extern struct tcp_congestion_ops tcp_reno;
3924 : :
3925 : : static __initdata unsigned long thash_entries;
3926 : 0 : static int __init set_thash_entries(char *str)
3927 : : {
3928 : : ssize_t ret;
3929 : :
3930 : 0 : if (!str)
3931 : : return 0;
3932 : :
3933 : : ret = kstrtoul(str, 0, &thash_entries);
3934 : 0 : if (ret)
3935 : : return 0;
3936 : :
3937 : 0 : return 1;
3938 : : }
3939 : : __setup("thash_entries=", set_thash_entries);
3940 : :
3941 : 3 : static void __init tcp_init_mem(void)
3942 : : {
3943 : 3 : unsigned long limit = nr_free_buffer_pages() / 16;
3944 : :
3945 : 3 : limit = max(limit, 128UL);
3946 : 3 : sysctl_tcp_mem[0] = limit / 4 * 3; /* 4.68 % */
3947 : 3 : sysctl_tcp_mem[1] = limit; /* 6.25 % */
3948 : 3 : sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2; /* 9.37 % */
3949 : 3 : }
3950 : :
3951 : 3 : void __init tcp_init(void)
3952 : : {
3953 : : int max_rshare, max_wshare, cnt;
3954 : : unsigned long limit;
3955 : : unsigned int i;
3956 : :
3957 : : BUILD_BUG_ON(TCP_MIN_SND_MSS <= MAX_TCP_OPTION_SPACE);
3958 : : BUILD_BUG_ON(sizeof(struct tcp_skb_cb) >
3959 : : FIELD_SIZEOF(struct sk_buff, cb));
3960 : :
3961 : 3 : percpu_counter_init(&tcp_sockets_allocated, 0, GFP_KERNEL);
3962 : 3 : percpu_counter_init(&tcp_orphan_count, 0, GFP_KERNEL);
3963 : 3 : inet_hashinfo_init(&tcp_hashinfo);
3964 : 3 : inet_hashinfo2_init(&tcp_hashinfo, "tcp_listen_portaddr_hash",
3965 : : thash_entries, 21, /* one slot per 2 MB*/
3966 : : 0, 64 * 1024);
3967 : 3 : tcp_hashinfo.bind_bucket_cachep =
3968 : 3 : kmem_cache_create("tcp_bind_bucket",
3969 : : sizeof(struct inet_bind_bucket), 0,
3970 : : SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
3971 : :
3972 : : /* Size and allocate the main established and bind bucket
3973 : : * hash tables.
3974 : : *
3975 : : * The methodology is similar to that of the buffer cache.
3976 : : */
3977 : 3 : tcp_hashinfo.ehash =
3978 : 3 : alloc_large_system_hash("TCP established",
3979 : : sizeof(struct inet_ehash_bucket),
3980 : : thash_entries,
3981 : : 17, /* one slot per 128 KB of memory */
3982 : : 0,
3983 : : NULL,
3984 : : &tcp_hashinfo.ehash_mask,
3985 : : 0,
3986 : 3 : thash_entries ? 0 : 512 * 1024);
3987 : 3 : for (i = 0; i <= tcp_hashinfo.ehash_mask; i++)
3988 : 3 : INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);
3989 : :
3990 : 3 : if (inet_ehash_locks_alloc(&tcp_hashinfo))
3991 : 0 : panic("TCP: failed to alloc ehash_locks");
3992 : 3 : tcp_hashinfo.bhash =
3993 : 3 : alloc_large_system_hash("TCP bind",
3994 : : sizeof(struct inet_bind_hashbucket),
3995 : 3 : tcp_hashinfo.ehash_mask + 1,
3996 : : 17, /* one slot per 128 KB of memory */
3997 : : 0,
3998 : : &tcp_hashinfo.bhash_size,
3999 : : NULL,
4000 : : 0,
4001 : : 64 * 1024);
4002 : 3 : tcp_hashinfo.bhash_size = 1U << tcp_hashinfo.bhash_size;
4003 : 3 : for (i = 0; i < tcp_hashinfo.bhash_size; i++) {
4004 : 3 : spin_lock_init(&tcp_hashinfo.bhash[i].lock);
4005 : 3 : INIT_HLIST_HEAD(&tcp_hashinfo.bhash[i].chain);
4006 : : }
4007 : :
4008 : :
4009 : 3 : cnt = tcp_hashinfo.ehash_mask + 1;
4010 : 3 : sysctl_tcp_max_orphans = cnt / 2;
4011 : :
4012 : 3 : tcp_init_mem();
4013 : : /* Set per-socket limits to no more than 1/128 the pressure threshold */
4014 : 3 : limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);
4015 : 3 : max_wshare = min(4UL*1024*1024, limit);
4016 : 3 : max_rshare = min(6UL*1024*1024, limit);
4017 : :
4018 : 3 : init_net.ipv4.sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
4019 : 3 : init_net.ipv4.sysctl_tcp_wmem[1] = 16*1024;
4020 : 3 : init_net.ipv4.sysctl_tcp_wmem[2] = max(64*1024, max_wshare);
4021 : :
4022 : 3 : init_net.ipv4.sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;
4023 : 3 : init_net.ipv4.sysctl_tcp_rmem[1] = 131072;
4024 : 3 : init_net.ipv4.sysctl_tcp_rmem[2] = max(131072, max_rshare);
4025 : :
4026 : 3 : pr_info("Hash tables configured (established %u bind %u)\n",
4027 : : tcp_hashinfo.ehash_mask + 1, tcp_hashinfo.bhash_size);
4028 : :
4029 : 3 : tcp_v4_init();
4030 : 3 : tcp_metrics_init();
4031 : 3 : BUG_ON(tcp_register_congestion_control(&tcp_reno) != 0);
4032 : 3 : tcp_tasklet_init();
4033 : 3 : }
|
