Branch data Line data Source code
1 : : /*
2 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
3 : : * operating system. INET is implemented using the BSD Socket
4 : : * interface as the means of communication with the user level.
5 : : *
6 : : * Implementation of the Transmission Control Protocol(TCP).
7 : : *
8 : : * Authors: Ross Biro
9 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 : : * Mark Evans, <evansmp@uhura.aston.ac.uk>
11 : : * Corey Minyard <wf-rch!minyard@relay.EU.net>
12 : : * Florian La Roche, <flla@stud.uni-sb.de>
13 : : * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
14 : : * Linus Torvalds, <torvalds@cs.helsinki.fi>
15 : : * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 : : * Matthew Dillon, <dillon@apollo.west.oic.com>
17 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
18 : : * Jorge Cwik, <jorge@laser.satlink.net>
19 : : *
20 : : * Fixes:
21 : : * Alan Cox : Numerous verify_area() calls
22 : : * Alan Cox : Set the ACK bit on a reset
23 : : * Alan Cox : Stopped it crashing if it closed while
24 : : * sk->inuse=1 and was trying to connect
25 : : * (tcp_err()).
26 : : * Alan Cox : All icmp error handling was broken
27 : : * pointers passed where wrong and the
28 : : * socket was looked up backwards. Nobody
29 : : * tested any icmp error code obviously.
30 : : * Alan Cox : tcp_err() now handled properly. It
31 : : * wakes people on errors. poll
32 : : * behaves and the icmp error race
33 : : * has gone by moving it into sock.c
34 : : * Alan Cox : tcp_send_reset() fixed to work for
35 : : * everything not just packets for
36 : : * unknown sockets.
37 : : * Alan Cox : tcp option processing.
38 : : * Alan Cox : Reset tweaked (still not 100%) [Had
39 : : * syn rule wrong]
40 : : * Herp Rosmanith : More reset fixes
41 : : * Alan Cox : No longer acks invalid rst frames.
42 : : * Acking any kind of RST is right out.
43 : : * Alan Cox : Sets an ignore me flag on an rst
44 : : * receive otherwise odd bits of prattle
45 : : * escape still
46 : : * Alan Cox : Fixed another acking RST frame bug.
47 : : * Should stop LAN workplace lockups.
48 : : * Alan Cox : Some tidyups using the new skb list
49 : : * facilities
50 : : * Alan Cox : sk->keepopen now seems to work
51 : : * Alan Cox : Pulls options out correctly on accepts
52 : : * Alan Cox : Fixed assorted sk->rqueue->next errors
53 : : * Alan Cox : PSH doesn't end a TCP read. Switched a
54 : : * bit to skb ops.
55 : : * Alan Cox : Tidied tcp_data to avoid a potential
56 : : * nasty.
57 : : * Alan Cox : Added some better commenting, as the
58 : : * tcp is hard to follow
59 : : * Alan Cox : Removed incorrect check for 20 * psh
60 : : * Michael O'Reilly : ack < copied bug fix.
61 : : * Johannes Stille : Misc tcp fixes (not all in yet).
62 : : * Alan Cox : FIN with no memory -> CRASH
63 : : * Alan Cox : Added socket option proto entries.
64 : : * Also added awareness of them to accept.
65 : : * Alan Cox : Added TCP options (SOL_TCP)
66 : : * Alan Cox : Switched wakeup calls to callbacks,
67 : : * so the kernel can layer network
68 : : * sockets.
69 : : * Alan Cox : Use ip_tos/ip_ttl settings.
70 : : * Alan Cox : Handle FIN (more) properly (we hope).
71 : : * Alan Cox : RST frames sent on unsynchronised
72 : : * state ack error.
73 : : * Alan Cox : Put in missing check for SYN bit.
74 : : * Alan Cox : Added tcp_select_window() aka NET2E
75 : : * window non shrink trick.
76 : : * Alan Cox : Added a couple of small NET2E timer
77 : : * fixes
78 : : * Charles Hedrick : TCP fixes
79 : : * Toomas Tamm : TCP window fixes
80 : : * Alan Cox : Small URG fix to rlogin ^C ack fight
81 : : * Charles Hedrick : Rewrote most of it to actually work
82 : : * Linus : Rewrote tcp_read() and URG handling
83 : : * completely
84 : : * Gerhard Koerting: Fixed some missing timer handling
85 : : * Matthew Dillon : Reworked TCP machine states as per RFC
86 : : * Gerhard Koerting: PC/TCP workarounds
87 : : * Adam Caldwell : Assorted timer/timing errors
88 : : * Matthew Dillon : Fixed another RST bug
89 : : * Alan Cox : Move to kernel side addressing changes.
90 : : * Alan Cox : Beginning work on TCP fastpathing
91 : : * (not yet usable)
92 : : * Arnt Gulbrandsen: Turbocharged tcp_check() routine.
93 : : * Alan Cox : TCP fast path debugging
94 : : * Alan Cox : Window clamping
95 : : * Michael Riepe : Bug in tcp_check()
96 : : * Matt Dillon : More TCP improvements and RST bug fixes
97 : : * Matt Dillon : Yet more small nasties remove from the
98 : : * TCP code (Be very nice to this man if
99 : : * tcp finally works 100%) 8)
100 : : * Alan Cox : BSD accept semantics.
101 : : * Alan Cox : Reset on closedown bug.
102 : : * Peter De Schrijver : ENOTCONN check missing in tcp_sendto().
103 : : * Michael Pall : Handle poll() after URG properly in
104 : : * all cases.
105 : : * Michael Pall : Undo the last fix in tcp_read_urg()
106 : : * (multi URG PUSH broke rlogin).
107 : : * Michael Pall : Fix the multi URG PUSH problem in
108 : : * tcp_readable(), poll() after URG
109 : : * works now.
110 : : * Michael Pall : recv(...,MSG_OOB) never blocks in the
111 : : * BSD api.
112 : : * Alan Cox : Changed the semantics of sk->socket to
113 : : * fix a race and a signal problem with
114 : : * accept() and async I/O.
115 : : * Alan Cox : Relaxed the rules on tcp_sendto().
116 : : * Yury Shevchuk : Really fixed accept() blocking problem.
117 : : * Craig I. Hagan : Allow for BSD compatible TIME_WAIT for
118 : : * clients/servers which listen in on
119 : : * fixed ports.
120 : : * Alan Cox : Cleaned the above up and shrank it to
121 : : * a sensible code size.
122 : : * Alan Cox : Self connect lockup fix.
123 : : * Alan Cox : No connect to multicast.
124 : : * Ross Biro : Close unaccepted children on master
125 : : * socket close.
126 : : * Alan Cox : Reset tracing code.
127 : : * Alan Cox : Spurious resets on shutdown.
128 : : * Alan Cox : Giant 15 minute/60 second timer error
129 : : * Alan Cox : Small whoops in polling before an
130 : : * accept.
131 : : * Alan Cox : Kept the state trace facility since
132 : : * it's handy for debugging.
133 : : * Alan Cox : More reset handler fixes.
134 : : * Alan Cox : Started rewriting the code based on
135 : : * the RFC's for other useful protocol
136 : : * references see: Comer, KA9Q NOS, and
137 : : * for a reference on the difference
138 : : * between specifications and how BSD
139 : : * works see the 4.4lite source.
140 : : * A.N.Kuznetsov : Don't time wait on completion of tidy
141 : : * close.
142 : : * Linus Torvalds : Fin/Shutdown & copied_seq changes.
143 : : * Linus Torvalds : Fixed BSD port reuse to work first syn
144 : : * Alan Cox : Reimplemented timers as per the RFC
145 : : * and using multiple timers for sanity.
146 : : * Alan Cox : Small bug fixes, and a lot of new
147 : : * comments.
148 : : * Alan Cox : Fixed dual reader crash by locking
149 : : * the buffers (much like datagram.c)
150 : : * Alan Cox : Fixed stuck sockets in probe. A probe
151 : : * now gets fed up of retrying without
152 : : * (even a no space) answer.
153 : : * Alan Cox : Extracted closing code better
154 : : * Alan Cox : Fixed the closing state machine to
155 : : * resemble the RFC.
156 : : * Alan Cox : More 'per spec' fixes.
157 : : * Jorge Cwik : Even faster checksumming.
158 : : * Alan Cox : tcp_data() doesn't ack illegal PSH
159 : : * only frames. At least one pc tcp stack
160 : : * generates them.
161 : : * Alan Cox : Cache last socket.
162 : : * Alan Cox : Per route irtt.
163 : : * Matt Day : poll()->select() match BSD precisely on error
164 : : * Alan Cox : New buffers
165 : : * Marc Tamsky : Various sk->prot->retransmits and
166 : : * sk->retransmits misupdating fixed.
167 : : * Fixed tcp_write_timeout: stuck close,
168 : : * and TCP syn retries gets used now.
169 : : * Mark Yarvis : In tcp_read_wakeup(), don't send an
170 : : * ack if state is TCP_CLOSED.
171 : : * Alan Cox : Look up device on a retransmit - routes may
172 : : * change. Doesn't yet cope with MSS shrink right
173 : : * but it's a start!
174 : : * Marc Tamsky : Closing in closing fixes.
175 : : * Mike Shaver : RFC1122 verifications.
176 : : * Alan Cox : rcv_saddr errors.
177 : : * Alan Cox : Block double connect().
178 : : * Alan Cox : Small hooks for enSKIP.
179 : : * Alexey Kuznetsov: Path MTU discovery.
180 : : * Alan Cox : Support soft errors.
181 : : * Alan Cox : Fix MTU discovery pathological case
182 : : * when the remote claims no mtu!
183 : : * Marc Tamsky : TCP_CLOSE fix.
184 : : * Colin (G3TNE) : Send a reset on syn ack replies in
185 : : * window but wrong (fixes NT lpd problems)
186 : : * Pedro Roque : Better TCP window handling, delayed ack.
187 : : * Joerg Reuter : No modification of locked buffers in
188 : : * tcp_do_retransmit()
189 : : * Eric Schenk : Changed receiver side silly window
190 : : * avoidance algorithm to BSD style
191 : : * algorithm. This doubles throughput
192 : : * against machines running Solaris,
193 : : * and seems to result in general
194 : : * improvement.
195 : : * Stefan Magdalinski : adjusted tcp_readable() to fix FIONREAD
196 : : * Willy Konynenberg : Transparent proxying support.
197 : : * Mike McLagan : Routing by source
198 : : * Keith Owens : Do proper merging with partial SKB's in
199 : : * tcp_do_sendmsg to avoid burstiness.
200 : : * Eric Schenk : Fix fast close down bug with
201 : : * shutdown() followed by close().
202 : : * Andi Kleen : Make poll agree with SIGIO
203 : : * Salvatore Sanfilippo : Support SO_LINGER with linger == 1 and
204 : : * lingertime == 0 (RFC 793 ABORT Call)
205 : : * Hirokazu Takahashi : Use copy_from_user() instead of
206 : : * csum_and_copy_from_user() if possible.
207 : : *
208 : : * This program is free software; you can redistribute it and/or
209 : : * modify it under the terms of the GNU General Public License
210 : : * as published by the Free Software Foundation; either version
211 : : * 2 of the License, or(at your option) any later version.
212 : : *
213 : : * Description of States:
214 : : *
215 : : * TCP_SYN_SENT sent a connection request, waiting for ack
216 : : *
217 : : * TCP_SYN_RECV received a connection request, sent ack,
218 : : * waiting for final ack in three-way handshake.
219 : : *
220 : : * TCP_ESTABLISHED connection established
221 : : *
222 : : * TCP_FIN_WAIT1 our side has shutdown, waiting to complete
223 : : * transmission of remaining buffered data
224 : : *
225 : : * TCP_FIN_WAIT2 all buffered data sent, waiting for remote
226 : : * to shutdown
227 : : *
228 : : * TCP_CLOSING both sides have shutdown but we still have
229 : : * data we have to finish sending
230 : : *
231 : : * TCP_TIME_WAIT timeout to catch resent junk before entering
232 : : * closed, can only be entered from FIN_WAIT2
233 : : * or CLOSING. Required because the other end
234 : : * may not have gotten our last ACK causing it
235 : : * to retransmit the data packet (which we ignore)
236 : : *
237 : : * TCP_CLOSE_WAIT remote side has shutdown and is waiting for
238 : : * us to finish writing our data and to shutdown
239 : : * (we have to close() to move on to LAST_ACK)
240 : : *
241 : : * TCP_LAST_ACK out side has shutdown after remote has
242 : : * shutdown. There may still be data in our
243 : : * buffer that we have to finish sending
244 : : *
245 : : * TCP_CLOSE socket is finished
246 : : */
247 : :
248 : : #define pr_fmt(fmt) "TCP: " fmt
249 : :
250 : : #include <linux/kernel.h>
251 : : #include <linux/module.h>
252 : : #include <linux/types.h>
253 : : #include <linux/fcntl.h>
254 : : #include <linux/poll.h>
255 : : #include <linux/init.h>
256 : : #include <linux/fs.h>
257 : : #include <linux/skbuff.h>
258 : : #include <linux/scatterlist.h>
259 : : #include <linux/splice.h>
260 : : #include <linux/net.h>
261 : : #include <linux/socket.h>
262 : : #include <linux/random.h>
263 : : #include <linux/bootmem.h>
264 : : #include <linux/highmem.h>
265 : : #include <linux/swap.h>
266 : : #include <linux/cache.h>
267 : : #include <linux/err.h>
268 : : #include <linux/crypto.h>
269 : : #include <linux/time.h>
270 : : #include <linux/slab.h>
271 : : #include <linux/uid_stat.h>
272 : :
273 : : #include <net/icmp.h>
274 : : #include <net/inet_common.h>
275 : : #include <net/tcp.h>
276 : : #include <net/xfrm.h>
277 : : #include <net/ip.h>
278 : : #include <net/ip6_route.h>
279 : : #include <net/ipv6.h>
280 : : #include <net/transp_v6.h>
281 : : #include <net/netdma.h>
282 : : #include <net/sock.h>
283 : :
284 : : #include <asm/uaccess.h>
285 : : #include <asm/ioctls.h>
286 : : #include <net/busy_poll.h>
287 : :
288 : : int sysctl_tcp_fin_timeout __read_mostly = TCP_FIN_TIMEOUT;
289 : :
290 : : int sysctl_tcp_min_tso_segs __read_mostly = 2;
291 : :
292 : : int sysctl_tcp_autocorking __read_mostly = 1;
293 : :
294 : : struct percpu_counter tcp_orphan_count;
295 : : EXPORT_SYMBOL_GPL(tcp_orphan_count);
296 : :
297 : : long sysctl_tcp_mem[3] __read_mostly;
298 : : int sysctl_tcp_wmem[3] __read_mostly;
299 : : int sysctl_tcp_rmem[3] __read_mostly;
300 : :
301 : : EXPORT_SYMBOL(sysctl_tcp_mem);
302 : : EXPORT_SYMBOL(sysctl_tcp_rmem);
303 : : EXPORT_SYMBOL(sysctl_tcp_wmem);
304 : :
305 : : atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
306 : : EXPORT_SYMBOL(tcp_memory_allocated);
307 : :
308 : : /*
309 : : * Current number of TCP sockets.
310 : : */
311 : : struct percpu_counter tcp_sockets_allocated;
312 : : EXPORT_SYMBOL(tcp_sockets_allocated);
313 : :
314 : : /*
315 : : * TCP splice context
316 : : */
317 : : struct tcp_splice_state {
318 : : struct pipe_inode_info *pipe;
319 : : size_t len;
320 : : unsigned int flags;
321 : : };
322 : :
323 : : /*
324 : : * Pressure flag: try to collapse.
325 : : * Technical note: it is used by multiple contexts non atomically.
326 : : * All the __sk_mem_schedule() is of this nature: accounting
327 : : * is strict, actions are advisory and have some latency.
328 : : */
329 : : int tcp_memory_pressure __read_mostly;
330 : : EXPORT_SYMBOL(tcp_memory_pressure);
331 : :
332 : 0 : void tcp_enter_memory_pressure(struct sock *sk)
333 : : {
334 [ # # ]: 0 : if (!tcp_memory_pressure) {
335 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
336 : 0 : tcp_memory_pressure = 1;
337 : : }
338 : 0 : }
339 : : EXPORT_SYMBOL(tcp_enter_memory_pressure);
340 : :
341 : : /* Convert seconds to retransmits based on initial and max timeout */
342 : : static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
343 : : {
344 : : u8 res = 0;
345 : :
346 [ # # ]: 1 : if (seconds > 0) {
347 : : int period = timeout;
348 : :
349 : : res = 1;
350 [ # # ]: 0 : while (seconds > period && res < 255) {
351 : 0 : res++;
352 : 0 : timeout <<= 1;
353 [ # # ]: 0 : if (timeout > rto_max)
354 : : timeout = rto_max;
355 : 0 : period += timeout;
356 : : }
357 : : }
358 : : return res;
359 : : }
360 : :
361 : : /* Convert retransmits to seconds based on initial and max timeout */
362 : : static int retrans_to_secs(u8 retrans, int timeout, int rto_max)
363 : : {
364 : : int period = 0;
365 : :
366 [ # # ]: 0 : if (retrans > 0) {
367 : : period = timeout;
368 [ # # ]: 0 : while (--retrans) {
369 : 0 : timeout <<= 1;
370 [ # # ]: 0 : if (timeout > rto_max)
371 : : timeout = rto_max;
372 : 0 : period += timeout;
373 : : }
374 : : }
375 : : return period;
376 : : }
377 : :
378 : : /* Address-family independent initialization for a tcp_sock.
379 : : *
380 : : * NOTE: A lot of things set to zero explicitly by call to
381 : : * sk_alloc() so need not be done here.
382 : : */
383 : 0 : void tcp_init_sock(struct sock *sk)
384 : : {
385 : : struct inet_connection_sock *icsk = inet_csk(sk);
386 : : struct tcp_sock *tp = tcp_sk(sk);
387 : :
388 : 78 : __skb_queue_head_init(&tp->out_of_order_queue);
389 : 78 : tcp_init_xmit_timers(sk);
390 : : tcp_prequeue_init(tp);
391 : 78 : INIT_LIST_HEAD(&tp->tsq_node);
392 : :
393 : 78 : icsk->icsk_rto = TCP_TIMEOUT_INIT;
394 : 78 : tp->mdev = TCP_TIMEOUT_INIT;
395 : :
396 : : /* So many TCP implementations out there (incorrectly) count the
397 : : * initial SYN frame in their delayed-ACK and congestion control
398 : : * algorithms that we must have the following bandaid to talk
399 : : * efficiently to them. -DaveM
400 : : */
401 : 78 : tp->snd_cwnd = TCP_INIT_CWND;
402 : :
403 : : /* See draft-stevens-tcpca-spec-01 for discussion of the
404 : : * initialization of these values.
405 : : */
406 : 78 : tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
407 : 78 : tp->snd_cwnd_clamp = ~0;
408 : 78 : tp->mss_cache = TCP_MSS_DEFAULT;
409 : :
410 : 78 : tp->reordering = sysctl_tcp_reordering;
411 : : tcp_enable_early_retrans(tp);
412 : 78 : icsk->icsk_ca_ops = &tcp_init_congestion_ops;
413 : :
414 : 78 : tp->tsoffset = 0;
415 : :
416 : 78 : sk->sk_state = TCP_CLOSE;
417 : :
418 : 78 : sk->sk_write_space = sk_stream_write_space;
419 : : sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
420 : :
421 : 78 : icsk->icsk_sync_mss = tcp_sync_mss;
422 : :
423 : 78 : sk->sk_sndbuf = sysctl_tcp_wmem[1];
424 : 78 : sk->sk_rcvbuf = sysctl_tcp_rmem[1];
425 : :
426 : : local_bh_disable();
427 : : sock_update_memcg(sk);
428 : : sk_sockets_allocated_inc(sk);
429 : : local_bh_enable();
430 : 78 : }
431 : : EXPORT_SYMBOL(tcp_init_sock);
432 : :
433 : : /*
434 : : * Wait for a TCP event.
435 : : *
436 : : * Note that we don't need to lock the socket, as the upper poll layers
437 : : * take care of normal races (between the test and the event) and we don't
438 : : * go look at any of the socket buffers directly.
439 : : */
440 : 0 : unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
441 : : {
442 : : unsigned int mask;
443 : 50190 : struct sock *sk = sock->sk;
444 : : const struct tcp_sock *tp = tcp_sk(sk);
445 : :
446 : : sock_rps_record_flow(sk);
447 : :
448 : 50190 : sock_poll_wait(file, sk_sleep(sk), wait);
449 [ + + ]: 50190 : if (sk->sk_state == TCP_LISTEN)
450 : 104 : return inet_csk_listen_poll(sk);
451 : :
452 : : /* Socket is not locked. We are protected from async events
453 : : * by poll logic and correct handling of state changes
454 : : * made by other threads is impossible in any case.
455 : : */
456 : :
457 : : mask = 0;
458 : :
459 : : /*
460 : : * POLLHUP is certainly not done right. But poll() doesn't
461 : : * have a notion of HUP in just one direction, and for a
462 : : * socket the read side is more interesting.
463 : : *
464 : : * Some poll() documentation says that POLLHUP is incompatible
465 : : * with the POLLOUT/POLLWR flags, so somebody should check this
466 : : * all. But careful, it tends to be safer to return too many
467 : : * bits than too few, and you can easily break real applications
468 : : * if you don't tell them that something has hung up!
469 : : *
470 : : * Check-me.
471 : : *
472 : : * Check number 1. POLLHUP is _UNMASKABLE_ event (see UNIX98 and
473 : : * our fs/select.c). It means that after we received EOF,
474 : : * poll always returns immediately, making impossible poll() on write()
475 : : * in state CLOSE_WAIT. One solution is evident --- to set POLLHUP
476 : : * if and only if shutdown has been made in both directions.
477 : : * Actually, it is interesting to look how Solaris and DUX
478 : : * solve this dilemma. I would prefer, if POLLHUP were maskable,
479 : : * then we could set it on SND_SHUTDOWN. BTW examples given
480 : : * in Stevens' books assume exactly this behaviour, it explains
481 : : * why POLLHUP is incompatible with POLLOUT. --ANK
482 : : *
483 : : * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
484 : : * blocking on fresh not-connected or disconnected socket. --ANK
485 : : */
486 [ + + ][ - + ]: 50086 : if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == TCP_CLOSE)
487 : : mask |= POLLHUP;
488 [ + + ]: 50086 : if (sk->sk_shutdown & RCV_SHUTDOWN)
489 : 23 : mask |= POLLIN | POLLRDNORM | POLLRDHUP;
490 : :
491 : : /* Connected or passive Fast Open socket? */
492 [ + - ][ - + ]: 50086 : if (sk->sk_state != TCP_SYN_SENT &&
493 [ # # ]: 0 : (sk->sk_state != TCP_SYN_RECV || tp->fastopen_rsk != NULL)) {
494 : : int target = sock_rcvlowat(sk, 0, INT_MAX);
495 : :
496 [ - + ][ # # ]: 100276 : if (tp->urg_seq == tp->copied_seq &&
497 [ # # ]: 0 : !sock_flag(sk, SOCK_URGINLINE) &&
498 : 0 : tp->urg_data)
499 : 0 : target++;
500 : :
501 : : /* Potential race condition. If read of tp below will
502 : : * escape above sk->sk_state, we can be illegally awaken
503 : : * in SYN_* states. */
504 [ + + ]: 50086 : if (tp->rcv_nxt - tp->copied_seq >= target)
505 : 375 : mask |= POLLIN | POLLRDNORM;
506 : :
507 [ + + ]: 50086 : if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
508 [ + - ]: 50076 : if (sk_stream_is_writeable(sk)) {
509 : 50076 : mask |= POLLOUT | POLLWRNORM;
510 : : } else { /* send SIGIO later */
511 : 0 : set_bit(SOCK_ASYNC_NOSPACE,
512 : : &sk->sk_socket->flags);
513 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
514 : :
515 : : /* Race breaker. If space is freed after
516 : : * wspace test but before the flags are set,
517 : : * IO signal will be lost.
518 : : */
519 [ # # ]: 0 : if (sk_stream_is_writeable(sk))
520 : 0 : mask |= POLLOUT | POLLWRNORM;
521 : : }
522 : : } else
523 : 10 : mask |= POLLOUT | POLLWRNORM;
524 : :
525 [ - + ]: 50086 : if (tp->urg_data & TCP_URG_VALID)
526 : 0 : mask |= POLLPRI;
527 : : }
528 : : /* This barrier is coupled with smp_wmb() in tcp_reset() */
529 : 0 : smp_rmb();
530 [ + + ]: 50086 : if (sk->sk_err)
531 : 10 : mask |= POLLERR;
532 : :
533 : 50086 : return mask;
534 : : }
535 : : EXPORT_SYMBOL(tcp_poll);
536 : :
537 : 0 : int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
538 : : {
539 : : struct tcp_sock *tp = tcp_sk(sk);
540 : : int answ;
541 : : bool slow;
542 : :
543 [ - + - - : 1 : switch (cmd) {
- ]
544 : : case SIOCINQ:
545 [ # # ]: 0 : if (sk->sk_state == TCP_LISTEN)
546 : : return -EINVAL;
547 : :
548 : 0 : slow = lock_sock_fast(sk);
549 [ # # ]: 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
550 : : answ = 0;
551 [ # # ][ # # ]: 0 : else if (sock_flag(sk, SOCK_URGINLINE) ||
552 [ # # ]: 0 : !tp->urg_data ||
553 [ # # ]: 0 : before(tp->urg_seq, tp->copied_seq) ||
554 : 0 : !before(tp->urg_seq, tp->rcv_nxt)) {
555 : :
556 : 0 : answ = tp->rcv_nxt - tp->copied_seq;
557 : :
558 : : /* Subtract 1, if FIN was received */
559 [ # # ][ # # ]: 0 : if (answ && sock_flag(sk, SOCK_DONE))
560 : 0 : answ--;
561 : : } else
562 : : answ = tp->urg_seq - tp->copied_seq;
563 : : unlock_sock_fast(sk, slow);
564 : : break;
565 : : case SIOCATMARK:
566 [ - + ][ # # ]: 1 : answ = tp->urg_data && tp->urg_seq == tp->copied_seq;
567 : 1 : break;
568 : : case SIOCOUTQ:
569 [ # # ]: 0 : if (sk->sk_state == TCP_LISTEN)
570 : : return -EINVAL;
571 : :
572 [ # # ]: 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
573 : : answ = 0;
574 : : else
575 : 0 : answ = tp->write_seq - tp->snd_una;
576 : : break;
577 : : case SIOCOUTQNSD:
578 [ # # ]: 0 : if (sk->sk_state == TCP_LISTEN)
579 : : return -EINVAL;
580 : :
581 [ # # ]: 0 : if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
582 : : answ = 0;
583 : : else
584 : 0 : answ = tp->write_seq - tp->snd_nxt;
585 : : break;
586 : : default:
587 : : return -ENOIOCTLCMD;
588 : : }
589 : :
590 : 1 : return put_user(answ, (int __user *)arg);
591 : : }
592 : : EXPORT_SYMBOL(tcp_ioctl);
593 : :
594 : : static inline void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
595 : : {
596 : 22464 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
597 : 22464 : tp->pushed_seq = tp->write_seq;
598 : : }
599 : :
600 : : static inline bool forced_push(const struct tcp_sock *tp)
601 : : {
602 : 956 : return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
603 : : }
604 : :
605 : : static inline void skb_entail(struct sock *sk, struct sk_buff *skb)
606 : : {
607 : : struct tcp_sock *tp = tcp_sk(sk);
608 : : struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
609 : :
610 : 23343 : skb->csum = 0;
611 : 23343 : tcb->seq = tcb->end_seq = tp->write_seq;
612 : 23343 : tcb->tcp_flags = TCPHDR_ACK;
613 : 23343 : tcb->sacked = 0;
614 : : skb_header_release(skb);
615 : : tcp_add_write_queue_tail(sk, skb);
616 : 23343 : sk->sk_wmem_queued += skb->truesize;
617 : 23343 : sk_mem_charge(sk, skb->truesize);
618 [ - + ][ # # ]: 23343 : if (tp->nonagle & TCP_NAGLE_PUSH)
619 : 0 : tp->nonagle &= ~TCP_NAGLE_PUSH;
620 : : }
621 : :
622 : : static inline void tcp_mark_urg(struct tcp_sock *tp, int flags)
623 : : {
624 [ - + ]: 22464 : if (flags & MSG_OOB)
625 : 0 : tp->snd_up = tp->write_seq;
626 : : }
627 : :
628 : : /* If a not yet filled skb is pushed, do not send it if
629 : : * we have data packets in Qdisc or NIC queues :
630 : : * Because TX completion will happen shortly, it gives a chance
631 : : * to coalesce future sendmsg() payload into this skb, without
632 : : * need for a timer, and with no latency trade off.
633 : : * As packets containing data payload have a bigger truesize
634 : : * than pure acks (dataless) packets, the last checks prevent
635 : : * autocorking if we only have an ACK in Qdisc/NIC queues,
636 : : * or if TX completion was delayed after we processed ACK packet.
637 : : */
638 : : static bool tcp_should_autocork(struct sock *sk, struct sk_buff *skb,
639 : : int size_goal)
640 : : {
641 [ + - ]: 22463 : return skb->len < size_goal &&
642 [ + + ]: 22463 : sysctl_tcp_autocorking &&
643 [ + ][ + ]: 44927 : skb != tcp_write_queue_head(sk) &&
644 : 9445 : atomic_read(&sk->sk_wmem_alloc) > skb->truesize;
645 : : }
646 : :
647 : 0 : static void tcp_push(struct sock *sk, int flags, int mss_now,
648 : : int nonagle, int size_goal)
649 : : {
650 : : struct tcp_sock *tp = tcp_sk(sk);
651 : : struct sk_buff *skb;
652 : :
653 [ + - ]: 22464 : if (!tcp_send_head(sk))
654 : : return;
655 : :
656 : : skb = tcp_write_queue_tail(sk);
657 [ - + ][ # # ]: 22464 : if (!(flags & MSG_MORE) || forced_push(tp))
658 : : tcp_mark_push(tp, skb);
659 : :
660 : : tcp_mark_urg(tp, flags);
661 : :
662 [ # # ]: 0 : if (tcp_should_autocork(sk, skb, size_goal)) {
663 : :
664 : : /* avoid atomic op if TSQ_THROTTLED bit is already set */
665 [ # # ]: 0 : if (!test_bit(TSQ_THROTTLED, &tp->tsq_flags)) {
666 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPAUTOCORKING);
667 : 0 : set_bit(TSQ_THROTTLED, &tp->tsq_flags);
668 : : }
669 : : /* It is possible TX completion already happened
670 : : * before we set TSQ_THROTTLED.
671 : : */
672 [ + - ]: 22464 : if (atomic_read(&sk->sk_wmem_alloc) > skb->truesize)
673 : : return;
674 : : }
675 : :
676 [ - + ]: 22464 : if (flags & MSG_MORE)
677 : : nonagle = TCP_NAGLE_CORK;
678 : :
679 : 22464 : __tcp_push_pending_frames(sk, mss_now, nonagle);
680 : : }
681 : :
682 : 0 : static int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
683 : : unsigned int offset, size_t len)
684 : : {
685 : 0 : struct tcp_splice_state *tss = rd_desc->arg.data;
686 : : int ret;
687 : :
688 : 0 : ret = skb_splice_bits(skb, offset, tss->pipe, min(rd_desc->count, len),
689 : : tss->flags);
690 [ # # ]: 0 : if (ret > 0)
691 : 0 : rd_desc->count -= ret;
692 : 0 : return ret;
693 : : }
694 : :
695 : 0 : static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
696 : : {
697 : : /* Store TCP splice context information in read_descriptor_t. */
698 : 0 : read_descriptor_t rd_desc = {
699 : : .arg.data = tss,
700 : 0 : .count = tss->len,
701 : : };
702 : :
703 : 0 : return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
704 : : }
705 : :
706 : : /**
707 : : * tcp_splice_read - splice data from TCP socket to a pipe
708 : : * @sock: socket to splice from
709 : : * @ppos: position (not valid)
710 : : * @pipe: pipe to splice to
711 : : * @len: number of bytes to splice
712 : : * @flags: splice modifier flags
713 : : *
714 : : * Description:
715 : : * Will read pages from given socket and fill them into a pipe.
716 : : *
717 : : **/
718 : 0 : ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
719 : : struct pipe_inode_info *pipe, size_t len,
720 : : unsigned int flags)
721 : : {
722 : 0 : struct sock *sk = sock->sk;
723 : 0 : struct tcp_splice_state tss = {
724 : : .pipe = pipe,
725 : : .len = len,
726 : : .flags = flags,
727 : : };
728 : : long timeo;
729 : : ssize_t spliced;
730 : : int ret;
731 : :
732 : : sock_rps_record_flow(sk);
733 : : /*
734 : : * We can't seek on a socket input
735 : : */
736 [ # # ]: 0 : if (unlikely(*ppos))
737 : : return -ESPIPE;
738 : :
739 : : ret = spliced = 0;
740 : :
741 : : lock_sock(sk);
742 : :
743 : 0 : timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK);
744 [ # # ]: 0 : while (tss.len) {
745 : 0 : ret = __tcp_splice_read(sk, &tss);
746 [ # # ]: 0 : if (ret < 0)
747 : : break;
748 [ # # ]: 0 : else if (!ret) {
749 [ # # ]: 0 : if (spliced)
750 : : break;
751 [ # # ]: 0 : if (sock_flag(sk, SOCK_DONE))
752 : : break;
753 [ # # ]: 0 : if (sk->sk_err) {
754 : : ret = sock_error(sk);
755 : 0 : break;
756 : : }
757 [ # # ]: 0 : if (sk->sk_shutdown & RCV_SHUTDOWN)
758 : : break;
759 [ # # ]: 0 : if (sk->sk_state == TCP_CLOSE) {
760 : : /*
761 : : * This occurs when user tries to read
762 : : * from never connected socket.
763 : : */
764 [ # # ]: 0 : if (!sock_flag(sk, SOCK_DONE))
765 : : ret = -ENOTCONN;
766 : : break;
767 : : }
768 [ # # ]: 0 : if (!timeo) {
769 : : ret = -EAGAIN;
770 : : break;
771 : : }
772 : 0 : sk_wait_data(sk, &timeo);
773 [ # # ]: 0 : if (signal_pending(current)) {
774 : 0 : ret = sock_intr_errno(timeo);
775 : 0 : break;
776 : : }
777 : 0 : continue;
778 : : }
779 : 0 : tss.len -= ret;
780 : 0 : spliced += ret;
781 : :
782 [ # # ]: 0 : if (!timeo)
783 : : break;
784 : 0 : release_sock(sk);
785 : : lock_sock(sk);
786 : :
787 [ # # ][ # # ]: 0 : if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
[ # # ]
788 [ # # ]: 0 : (sk->sk_shutdown & RCV_SHUTDOWN) ||
789 : 0 : signal_pending(current))
790 : : break;
791 : : }
792 : :
793 : 0 : release_sock(sk);
794 : :
795 [ # # ]: 0 : if (spliced)
796 : : return spliced;
797 : :
798 : 0 : return ret;
799 : : }
800 : : EXPORT_SYMBOL(tcp_splice_read);
801 : :
802 : 0 : struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp)
803 : : {
804 : : struct sk_buff *skb;
805 : :
806 : : /* The TCP header must be at least 32-bit aligned. */
807 : 23343 : size = ALIGN(size, 4);
808 : :
809 : 23343 : skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
810 [ + - ]: 46686 : if (skb) {
811 [ + - ]: 23343 : if (sk_wmem_schedule(sk, skb->truesize)) {
812 : 23343 : skb_reserve(skb, sk->sk_prot->max_header);
813 : : /*
814 : : * Make sure that we have exactly size bytes
815 : : * available to the caller, no more, no less.
816 : : */
817 : 23343 : skb->reserved_tailroom = skb->end - skb->tail - size;
818 : 23343 : return skb;
819 : : }
820 : 0 : __kfree_skb(skb);
821 : : } else {
822 : 0 : sk->sk_prot->enter_memory_pressure(sk);
823 : : sk_stream_moderate_sndbuf(sk);
824 : : }
825 : : return NULL;
826 : : }
827 : :
828 : 0 : static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now,
829 : : int large_allowed)
830 : : {
831 : : struct tcp_sock *tp = tcp_sk(sk);
832 : : u32 xmit_size_goal, old_size_goal;
833 : :
834 : : xmit_size_goal = mss_now;
835 : :
836 [ + - ][ + + ]: 22465 : if (large_allowed && sk_can_gso(sk)) {
837 : : u32 gso_size, hlen;
838 : :
839 : : /* Maybe we should/could use sk->sk_prot->max_header here ? */
840 : 1773 : hlen = inet_csk(sk)->icsk_af_ops->net_header_len +
841 : 1182 : inet_csk(sk)->icsk_ext_hdr_len +
842 : 591 : tp->tcp_header_len;
843 : :
844 : : /* Goal is to send at least one packet per ms,
845 : : * not one big TSO packet every 100 ms.
846 : : * This preserves ACK clocking and is consistent
847 : : * with tcp_tso_should_defer() heuristic.
848 : : */
849 : 591 : gso_size = sk->sk_pacing_rate / (2 * MSEC_PER_SEC);
850 : 591 : gso_size = max_t(u32, gso_size,
851 : : sysctl_tcp_min_tso_segs * mss_now);
852 : :
853 : 591 : xmit_size_goal = min_t(u32, gso_size,
854 : : sk->sk_gso_max_size - 1 - hlen);
855 : :
856 : 1182 : xmit_size_goal = tcp_bound_to_half_wnd(tp, xmit_size_goal);
857 : :
858 : : /* We try hard to avoid divides here */
859 : 591 : old_size_goal = tp->xmit_size_goal_segs * mss_now;
860 : :
861 [ + ][ + ]: 591 : if (likely(old_size_goal <= xmit_size_goal &&
862 : : old_size_goal + mss_now > xmit_size_goal)) {
863 : : xmit_size_goal = old_size_goal;
864 : : } else {
865 : 17 : tp->xmit_size_goal_segs =
866 : 17 : min_t(u16, xmit_size_goal / mss_now,
867 : : sk->sk_gso_max_segs);
868 : 17 : xmit_size_goal = tp->xmit_size_goal_segs * mss_now;
869 : : }
870 : : }
871 : :
872 : 0 : return max(xmit_size_goal, mss_now);
873 : : }
874 : :
875 : 0 : static int tcp_send_mss(struct sock *sk, int *size_goal, int flags)
876 : : {
877 : : int mss_now;
878 : :
879 : 22465 : mss_now = tcp_current_mss(sk);
880 : 22465 : *size_goal = tcp_xmit_size_goal(sk, mss_now, !(flags & MSG_OOB));
881 : :
882 : 22465 : return mss_now;
883 : : }
884 : :
885 : 0 : static ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset,
886 : : size_t size, int flags)
887 : : {
888 : : struct tcp_sock *tp = tcp_sk(sk);
889 : : int mss_now, size_goal;
890 : : int err;
891 : : ssize_t copied;
892 : 0 : long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
893 : :
894 : : /* Wait for a connection to finish. One exception is TCP Fast Open
895 : : * (passive side) where data is allowed to be sent before a connection
896 : : * is fully established.
897 : : */
898 [ # # ][ # # ]: 0 : if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
899 : : !tcp_passive_fastopen(sk)) {
900 [ # # ]: 0 : if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
901 : : goto out_err;
902 : : }
903 : :
904 : 0 : clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
905 : :
906 : 0 : mss_now = tcp_send_mss(sk, &size_goal, flags);
907 : : copied = 0;
908 : :
909 : : err = -EPIPE;
910 [ # # ][ # # ]: 0 : if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
911 : : goto out_err;
912 : :
913 [ # # ]: 0 : while (size > 0) {
914 : 0 : struct sk_buff *skb = tcp_write_queue_tail(sk);
915 : : int copy, i;
916 : : bool can_coalesce;
917 : :
918 [ # # ][ # # ]: 0 : if (!tcp_send_head(sk) || (copy = size_goal - skb->len) <= 0) {
919 : : new_segment:
920 [ # # ]: 0 : if (!sk_stream_memory_free(sk))
921 : : goto wait_for_sndbuf;
922 : :
923 : 0 : skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation);
924 [ # # ]: 0 : if (!skb)
925 : : goto wait_for_memory;
926 : :
927 : : skb_entail(sk, skb);
928 : 0 : copy = size_goal;
929 : : }
930 : :
931 [ # # ]: 0 : if (copy > size)
932 : 0 : copy = size;
933 : :
934 : 0 : i = skb_shinfo(skb)->nr_frags;
935 : : can_coalesce = skb_can_coalesce(skb, i, page, offset);
936 [ # # ]: 0 : if (!can_coalesce && i >= MAX_SKB_FRAGS) {
937 : : tcp_mark_push(tp, skb);
938 : : goto new_segment;
939 : : }
940 [ # # ]: 0 : if (!sk_wmem_schedule(sk, copy))
941 : : goto wait_for_memory;
942 : :
943 [ # # ]: 0 : if (can_coalesce) {
944 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
945 : : } else {
946 : : get_page(page);
947 : : skb_fill_page_desc(skb, i, page, offset, copy);
948 : : }
949 : 0 : skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG;
950 : :
951 : 0 : skb->len += copy;
952 : 0 : skb->data_len += copy;
953 : 0 : skb->truesize += copy;
954 : 0 : sk->sk_wmem_queued += copy;
955 : : sk_mem_charge(sk, copy);
956 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
957 : 0 : tp->write_seq += copy;
958 : 0 : TCP_SKB_CB(skb)->end_seq += copy;
959 : 0 : skb_shinfo(skb)->gso_segs = 0;
960 : :
961 [ # # ]: 0 : if (!copied)
962 : 0 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
963 : :
964 : 0 : copied += copy;
965 : 0 : offset += copy;
966 [ # # ]: 0 : if (!(size -= copy))
967 : : goto out;
968 : :
969 [ # # ][ # # ]: 0 : if (skb->len < size_goal || (flags & MSG_OOB))
970 : 0 : continue;
971 : :
972 [ # # ]: 0 : if (forced_push(tp)) {
973 : : tcp_mark_push(tp, skb);
974 : 0 : __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
975 [ # # ]: 0 : } else if (skb == tcp_send_head(sk))
976 : 0 : tcp_push_one(sk, mss_now);
977 : 0 : continue;
978 : :
979 : : wait_for_sndbuf:
980 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
981 : : wait_for_memory:
982 : 0 : tcp_push(sk, flags & ~MSG_MORE, mss_now,
983 : : TCP_NAGLE_PUSH, size_goal);
984 : :
985 [ # # ]: 0 : if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
986 : : goto do_error;
987 : :
988 : 0 : mss_now = tcp_send_mss(sk, &size_goal, flags);
989 : : }
990 : :
991 : : out:
992 [ # # ][ # # ]: 0 : if (copied && !(flags & MSG_SENDPAGE_NOTLAST))
993 : 0 : tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
994 : 0 : return copied;
995 : :
996 : : do_error:
997 [ # # ]: 0 : if (copied)
998 : : goto out;
999 : : out_err:
1000 : 0 : return sk_stream_error(sk, flags, err);
1001 : : }
1002 : :
1003 : 0 : int tcp_sendpage(struct sock *sk, struct page *page, int offset,
1004 : : size_t size, int flags)
1005 : : {
1006 : : ssize_t res;
1007 : :
1008 [ # # ][ # # ]: 0 : if (!(sk->sk_route_caps & NETIF_F_SG) ||
1009 : 0 : !(sk->sk_route_caps & NETIF_F_ALL_CSUM))
1010 : 0 : return sock_no_sendpage(sk->sk_socket, page, offset, size,
1011 : : flags);
1012 : :
1013 : : lock_sock(sk);
1014 : 0 : res = do_tcp_sendpages(sk, page, offset, size, flags);
1015 : 0 : release_sock(sk);
1016 : 0 : return res;
1017 : : }
1018 : : EXPORT_SYMBOL(tcp_sendpage);
1019 : :
1020 : : static inline int select_size(const struct sock *sk, bool sg)
1021 : : {
1022 : : const struct tcp_sock *tp = tcp_sk(sk);
1023 : 23343 : int tmp = tp->mss_cache;
1024 : :
1025 [ + + ]: 23343 : if (sg) {
1026 [ - + ]: 591 : if (sk_can_gso(sk)) {
1027 : : /* Small frames wont use a full page:
1028 : : * Payload will immediately follow tcp header.
1029 : : */
1030 : : tmp = SKB_WITH_OVERHEAD(2048 - MAX_TCP_HEADER);
1031 : : } else {
1032 : : int pgbreak = SKB_MAX_HEAD(MAX_TCP_HEADER);
1033 : :
1034 [ # # ][ # # ]: 0 : if (tmp >= pgbreak &&
1035 : : tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)
1036 : : tmp = pgbreak;
1037 : : }
1038 : : }
1039 : :
1040 : : return tmp;
1041 : : }
1042 : :
1043 : 0 : void tcp_free_fastopen_req(struct tcp_sock *tp)
1044 : : {
1045 [ # # ][ - + ]: 104 : if (tp->fastopen_req != NULL) {
1046 : 0 : kfree(tp->fastopen_req);
1047 : 0 : tp->fastopen_req = NULL;
1048 : : }
1049 : 0 : }
1050 : :
1051 : 0 : static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg,
1052 : : int *copied, size_t size)
1053 : : {
1054 : : struct tcp_sock *tp = tcp_sk(sk);
1055 : : int err, flags;
1056 : :
1057 [ # # ]: 0 : if (!(sysctl_tcp_fastopen & TFO_CLIENT_ENABLE))
1058 : : return -EOPNOTSUPP;
1059 [ # # ]: 0 : if (tp->fastopen_req != NULL)
1060 : : return -EALREADY; /* Another Fast Open is in progress */
1061 : :
1062 : 0 : tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request),
1063 : : sk->sk_allocation);
1064 [ # # ]: 0 : if (unlikely(tp->fastopen_req == NULL))
1065 : : return -ENOBUFS;
1066 : 0 : tp->fastopen_req->data = msg;
1067 : 0 : tp->fastopen_req->size = size;
1068 : :
1069 [ # # ]: 0 : flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0;
1070 : 0 : err = __inet_stream_connect(sk->sk_socket, msg->msg_name,
1071 : : msg->msg_namelen, flags);
1072 : 0 : *copied = tp->fastopen_req->copied;
1073 : : tcp_free_fastopen_req(tp);
1074 : 0 : return err;
1075 : : }
1076 : :
1077 : 0 : int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1078 : : size_t size)
1079 : : {
1080 : : struct iovec *iov;
1081 : : struct tcp_sock *tp = tcp_sk(sk);
1082 : 23420 : struct sk_buff *skb;
1083 : : int iovlen, flags, err, copied = 0;
1084 : 22471 : int mss_now = 0, size_goal, copied_syn = 0, offset = 0;
1085 : : bool sg;
1086 : : long timeo;
1087 : :
1088 : : lock_sock(sk);
1089 : :
1090 : 22471 : flags = msg->msg_flags;
1091 [ - + ]: 22471 : if (flags & MSG_FASTOPEN) {
1092 : 0 : err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size);
1093 [ # # ][ # # ]: 0 : if (err == -EINPROGRESS && copied_syn > 0)
1094 : : goto out;
1095 [ # # ]: 0 : else if (err)
1096 : : goto out_err;
1097 : 0 : offset = copied_syn;
1098 : : }
1099 : :
1100 : 44942 : timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
1101 : :
1102 : : /* Wait for a connection to finish. One exception is TCP Fast Open
1103 : : * (passive side) where data is allowed to be sent before a connection
1104 : : * is fully established.
1105 : : */
1106 [ + + ][ + - ]: 22477 : if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
1107 : : !tcp_passive_fastopen(sk)) {
1108 [ - + ]: 6 : if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
1109 : : goto do_error;
1110 : : }
1111 : :
1112 [ - + ]: 22465 : if (unlikely(tp->repair)) {
1113 [ # # ]: 0 : if (tp->repair_queue == TCP_RECV_QUEUE) {
1114 : 0 : copied = tcp_send_rcvq(sk, msg, size);
1115 : 0 : goto out;
1116 : : }
1117 : :
1118 : : err = -EINVAL;
1119 [ # # ]: 0 : if (tp->repair_queue == TCP_NO_QUEUE)
1120 : : goto out_err;
1121 : :
1122 : : /* 'common' sending to sendq */
1123 : : }
1124 : :
1125 : : /* This should be in poll */
1126 : 22465 : clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1127 : :
1128 : 22465 : mss_now = tcp_send_mss(sk, &size_goal, flags);
1129 : :
1130 : : /* Ok commence sending. */
1131 : 22465 : iovlen = msg->msg_iovlen;
1132 : 22465 : iov = msg->msg_iov;
1133 : : copied = 0;
1134 : :
1135 : : err = -EPIPE;
1136 [ + - ][ + - ]: 22465 : if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
1137 : : goto out_err;
1138 : :
1139 : 22465 : sg = !!(sk->sk_route_caps & NETIF_F_SG);
1140 : :
1141 [ + - ]: 22465 : while (--iovlen >= 0) {
1142 : 22465 : size_t seglen = iov->iov_len;
1143 : 22465 : unsigned char __user *from = iov->iov_base;
1144 : :
1145 : 22465 : iov++;
1146 [ - + ]: 22465 : if (unlikely(offset > 0)) { /* Skip bytes copied in SYN */
1147 [ # # ]: 0 : if (offset >= seglen) {
1148 : 0 : offset -= seglen;
1149 : 0 : continue;
1150 : : }
1151 : 0 : seglen -= offset;
1152 : 22465 : from += offset;
1153 : : offset = 0;
1154 : : }
1155 : :
1156 [ + - ]: 23421 : while (seglen > 0) {
1157 : : int copy = 0;
1158 : 23421 : int max = size_goal;
1159 : :
1160 : : skb = tcp_write_queue_tail(sk);
1161 [ + + ]: 23421 : if (tcp_send_head(sk)) {
1162 [ + - ]: 82 : if (skb->ip_summed == CHECKSUM_NONE)
1163 : : max = mss_now;
1164 : 82 : copy = max - skb->len;
1165 : : }
1166 : :
1167 [ + + ]: 23421 : if (copy <= 0) {
1168 : : new_segment:
1169 : : /* Allocate new segment. If the interface is SG,
1170 : : * allocate skb fitting to single page.
1171 : : */
1172 [ + - ]: 23343 : if (!sk_stream_memory_free(sk))
1173 : : goto wait_for_sndbuf;
1174 : :
1175 : 23343 : skb = sk_stream_alloc_skb(sk,
1176 : : select_size(sk, sg),
1177 : : sk->sk_allocation);
1178 [ + - ]: 23343 : if (!skb)
1179 : : goto wait_for_memory;
1180 : :
1181 : : /*
1182 : : * All packets are restored as if they have
1183 : : * already been sent.
1184 : : */
1185 [ - + ]: 23343 : if (tp->repair)
1186 : 0 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
1187 : :
1188 : : /*
1189 : : * Check whether we can use HW checksum.
1190 : : */
1191 [ + + ]: 23343 : if (sk->sk_route_caps & NETIF_F_ALL_CSUM)
1192 : 591 : skb->ip_summed = CHECKSUM_PARTIAL;
1193 : :
1194 : : skb_entail(sk, skb);
1195 : 23343 : copy = size_goal;
1196 : : max = size_goal;
1197 : : }
1198 : :
1199 : : /* Try to append data to the end of skb. */
1200 [ + + ]: 23421 : if (copy > seglen)
1201 : 22464 : copy = seglen;
1202 : :
1203 : : /* Where to copy to? */
1204 [ + - ]: 23421 : if (skb_availroom(skb) > 0) {
1205 : : /* We have some space in skb head. Superb! */
1206 : 23421 : copy = min_t(int, copy, skb_availroom(skb));
1207 : : err = skb_add_data_nocache(sk, skb, from, copy);
1208 [ + + ]: 23421 : if (err)
1209 : : goto do_fault;
1210 : : } else {
1211 : : bool merge = true;
1212 : 0 : int i = skb_shinfo(skb)->nr_frags;
1213 : : struct page_frag *pfrag = sk_page_frag(sk);
1214 : :
1215 [ # # ]: 0 : if (!sk_page_frag_refill(sk, pfrag))
1216 : : goto wait_for_memory;
1217 : :
1218 [ # # ]: 0 : if (!skb_can_coalesce(skb, i, pfrag->page,
1219 : 0 : pfrag->offset)) {
1220 [ # # ]: 0 : if (i == MAX_SKB_FRAGS || !sg) {
1221 : : tcp_mark_push(tp, skb);
1222 : : goto new_segment;
1223 : : }
1224 : : merge = false;
1225 : : }
1226 : :
1227 : 0 : copy = min_t(int, copy, pfrag->size - pfrag->offset);
1228 : :
1229 [ # # ]: 0 : if (!sk_wmem_schedule(sk, copy))
1230 : : goto wait_for_memory;
1231 : :
1232 : 0 : err = skb_copy_to_page_nocache(sk, from, skb,
1233 : : pfrag->page,
1234 : 0 : pfrag->offset,
1235 : : copy);
1236 [ # # ]: 0 : if (err)
1237 : : goto do_error;
1238 : :
1239 : : /* Update the skb. */
1240 [ # # ]: 0 : if (merge) {
1241 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1242 : : } else {
1243 : 0 : skb_fill_page_desc(skb, i, pfrag->page,
1244 : 0 : pfrag->offset, copy);
1245 : 0 : get_page(pfrag->page);
1246 : : }
1247 : 0 : pfrag->offset += copy;
1248 : : }
1249 : :
1250 [ + + ]: 23420 : if (!copied)
1251 : 22464 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
1252 : :
1253 : 23420 : tp->write_seq += copy;
1254 : 23420 : TCP_SKB_CB(skb)->end_seq += copy;
1255 : 23420 : skb_shinfo(skb)->gso_segs = 0;
1256 : :
1257 : 23420 : from += copy;
1258 : 23420 : copied += copy;
1259 [ + + ][ - + ]: 23420 : if ((seglen -= copy) == 0 && iovlen == 0)
1260 : : goto out;
1261 : :
1262 [ + - ][ + - ]: 956 : if (skb->len < max || (flags & MSG_OOB) || unlikely(tp->repair))
[ - + ]
1263 : 0 : continue;
1264 : :
1265 [ - + ]: 956 : if (forced_push(tp)) {
1266 : : tcp_mark_push(tp, skb);
1267 : 0 : __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
1268 [ + - ]: 956 : } else if (skb == tcp_send_head(sk))
1269 : 956 : tcp_push_one(sk, mss_now);
1270 : 956 : continue;
1271 : :
1272 : : wait_for_sndbuf:
1273 : 0 : set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1274 : : wait_for_memory:
1275 [ # # ]: 0 : if (copied)
1276 : 0 : tcp_push(sk, flags & ~MSG_MORE, mss_now,
1277 : : TCP_NAGLE_PUSH, size_goal);
1278 : :
1279 [ # # ]: 0 : if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
1280 : : goto do_error;
1281 : :
1282 : 956 : mss_now = tcp_send_mss(sk, &size_goal, flags);
1283 : : }
1284 : : }
1285 : :
1286 : : out:
1287 [ + - ]: 22464 : if (copied)
1288 : 22464 : tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
1289 : 22464 : release_sock(sk);
1290 : :
1291 : : if (copied + copied_syn)
1292 : : uid_stat_tcp_snd(from_kuid(&init_user_ns, current_uid()),
1293 : : copied + copied_syn);
1294 : 22464 : return copied + copied_syn;
1295 : :
1296 : : do_fault:
1297 [ + - ]: 1 : if (!skb->len) {
1298 : : tcp_unlink_write_queue(skb, sk);
1299 : : /* It is the one place in all of TCP, except connection
1300 : : * reset, where we can be unlinking the send_head.
1301 : : */
1302 : : tcp_check_send_head(sk, skb);
1303 : : sk_wmem_free_skb(sk, skb);
1304 : : }
1305 : :
1306 : : do_error:
1307 [ - + ]: 7 : if (copied + copied_syn)
1308 : : goto out;
1309 : : out_err:
1310 : 7 : err = sk_stream_error(sk, flags, err);
1311 : 7 : release_sock(sk);
1312 : 7 : return err;
1313 : : }
1314 : : EXPORT_SYMBOL(tcp_sendmsg);
1315 : :
1316 : : /*
1317 : : * Handle reading urgent data. BSD has very simple semantics for
1318 : : * this, no blocking and very strange errors 8)
1319 : : */
1320 : :
1321 : 4 : static int tcp_recv_urg(struct sock *sk, struct msghdr *msg, int len, int flags)
1322 : : {
1323 : : struct tcp_sock *tp = tcp_sk(sk);
1324 : :
1325 : : /* No URG data to read. */
1326 [ + - ][ - + ]: 4 : if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
[ # # ]
1327 : : tp->urg_data == TCP_URG_READ)
1328 : : return -EINVAL; /* Yes this is right ! */
1329 : :
1330 [ # # ][ # # ]: 0 : if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE))
1331 : : return -ENOTCONN;
1332 : :
1333 [ # # ]: 4 : if (tp->urg_data & TCP_URG_VALID) {
1334 : : int err = 0;
1335 : 0 : char c = tp->urg_data;
1336 : :
1337 [ # # ]: 0 : if (!(flags & MSG_PEEK))
1338 : 0 : tp->urg_data = TCP_URG_READ;
1339 : :
1340 : : /* Read urgent data. */
1341 : 0 : msg->msg_flags |= MSG_OOB;
1342 : :
1343 [ # # ]: 0 : if (len > 0) {
1344 [ # # ]: 0 : if (!(flags & MSG_TRUNC))
1345 : 0 : err = memcpy_toiovec(msg->msg_iov, &c, 1);
1346 : : len = 1;
1347 : : } else
1348 : 0 : msg->msg_flags |= MSG_TRUNC;
1349 : :
1350 [ # # ]: 0 : return err ? -EFAULT : len;
1351 : : }
1352 : :
1353 [ # # ][ # # ]: 0 : if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN))
1354 : : return 0;
1355 : :
1356 : : /* Fixed the recv(..., MSG_OOB) behaviour. BSD docs and
1357 : : * the available implementations agree in this case:
1358 : : * this call should never block, independent of the
1359 : : * blocking state of the socket.
1360 : : * Mike <pall@rz.uni-karlsruhe.de>
1361 : : */
1362 : : return -EAGAIN;
1363 : : }
1364 : :
1365 : 0 : static int tcp_peek_sndq(struct sock *sk, struct msghdr *msg, int len)
1366 : : {
1367 : : struct sk_buff *skb;
1368 : : int copied = 0, err = 0;
1369 : :
1370 : : /* XXX -- need to support SO_PEEK_OFF */
1371 : :
1372 [ # # ]: 0 : skb_queue_walk(&sk->sk_write_queue, skb) {
1373 : 0 : err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, skb->len);
1374 [ # # ]: 0 : if (err)
1375 : : break;
1376 : :
1377 : 0 : copied += skb->len;
1378 : : }
1379 : :
1380 [ # # ]: 0 : return err ?: copied;
1381 : : }
1382 : :
1383 : : /* Clean up the receive buffer for full frames taken by the user,
1384 : : * then send an ACK if necessary. COPIED is the number of bytes
1385 : : * tcp_recvmsg has given to the user so far, it speeds up the
1386 : : * calculation of whether or not we must ACK for the sake of
1387 : : * a window update.
1388 : : */
1389 : 0 : void tcp_cleanup_rbuf(struct sock *sk, int copied)
1390 : : {
1391 : : struct tcp_sock *tp = tcp_sk(sk);
1392 : : bool time_to_ack = false;
1393 : :
1394 : 19387 : struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
1395 : :
1396 [ + + ][ + - ]: 19387 : WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq),
[ - + ]
1397 : : "cleanup rbuf bug: copied %X seq %X rcvnxt %X\n",
1398 : : tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt);
1399 : :
1400 [ + + ]: 38774 : if (inet_csk_ack_scheduled(sk)) {
1401 : : const struct inet_connection_sock *icsk = inet_csk(sk);
1402 : : /* Delayed ACKs frequently hit locked sockets during bulk
1403 : : * receive. */
1404 [ + - ][ + - ]: 18682 : if (icsk->icsk_ack.blocked ||
1405 : : /* Once-per-two-segments ACK was not sent by tcp_input.c */
1406 [ + + ]: 18682 : tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
1407 : : /*
1408 : : * If this read emptied read buffer, we send ACK, if
1409 : : * connection is not bidirectional, user drained
1410 : : * receive buffer and there was a small segment
1411 : : * in queue.
1412 : : */
1413 [ + - ]: 18670 : (copied > 0 &&
1414 [ + + ]: 18670 : ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED2) ||
1415 [ - + ]: 18668 : ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED) &&
1416 [ # # ]: 0 : !icsk->icsk_ack.pingpong)) &&
1417 : 0 : !atomic_read(&sk->sk_rmem_alloc)))
1418 : : time_to_ack = true;
1419 : : }
1420 : :
1421 : : /* We send an ACK if we can now advertise a non-zero window
1422 : : * which has been raised "significantly".
1423 : : *
1424 : : * Even if window raised up to infinity, do not send window open ACK
1425 : : * in states, where we will not receive more. It is useless.
1426 : : */
1427 [ + + ][ + + ]: 19387 : if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1428 : : __u32 rcv_window_now = tcp_receive_window(tp);
1429 : :
1430 : : /* Optimize, __tcp_select_window() is not cheap. */
1431 [ + - ]: 18784 : if (2*rcv_window_now <= tp->window_clamp) {
1432 : 18784 : __u32 new_window = __tcp_select_window(sk);
1433 : :
1434 : : /* Send ACK now, if this read freed lots of space
1435 : : * in our buffer. Certainly, new_window is new window.
1436 : : * We can advertise it now, if it is not less than current one.
1437 : : * "Lots" means "at least twice" here.
1438 : : */
1439 [ + - ][ - + ]: 18784 : if (new_window && new_window >= 2 * rcv_window_now)
1440 : : time_to_ack = true;
1441 : : }
1442 : : }
1443 [ - + ]: 19387 : if (time_to_ack)
1444 : 0 : tcp_send_ack(sk);
1445 : 19387 : }
1446 : :
1447 : 0 : static void tcp_prequeue_process(struct sock *sk)
1448 : : {
1449 : : struct sk_buff *skb;
1450 : : struct tcp_sock *tp = tcp_sk(sk);
1451 : :
1452 : 1152 : NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);
1453 : :
1454 : : /* RX process wants to run with disabled BHs, though it is not
1455 : : * necessary */
1456 : : local_bh_disable();
1457 [ + + ]: 1152 : while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
1458 : : sk_backlog_rcv(sk, skb);
1459 : : local_bh_enable();
1460 : :
1461 : : /* Clear memory counter. */
1462 : 576 : tp->ucopy.memory = 0;
1463 : 576 : }
1464 : :
1465 : : #ifdef CONFIG_NET_DMA
1466 : : static void tcp_service_net_dma(struct sock *sk, bool wait)
1467 : : {
1468 : : dma_cookie_t done, used;
1469 : : dma_cookie_t last_issued;
1470 : : struct tcp_sock *tp = tcp_sk(sk);
1471 : :
1472 : : if (!tp->ucopy.dma_chan)
1473 : : return;
1474 : :
1475 : : last_issued = tp->ucopy.dma_cookie;
1476 : : dma_async_issue_pending(tp->ucopy.dma_chan);
1477 : :
1478 : : do {
1479 : : if (dma_async_is_tx_complete(tp->ucopy.dma_chan,
1480 : : last_issued, &done,
1481 : : &used) == DMA_COMPLETE) {
1482 : : /* Safe to free early-copied skbs now */
1483 : : __skb_queue_purge(&sk->sk_async_wait_queue);
1484 : : break;
1485 : : } else {
1486 : : struct sk_buff *skb;
1487 : : while ((skb = skb_peek(&sk->sk_async_wait_queue)) &&
1488 : : (dma_async_is_complete(skb->dma_cookie, done,
1489 : : used) == DMA_COMPLETE)) {
1490 : : __skb_dequeue(&sk->sk_async_wait_queue);
1491 : : kfree_skb(skb);
1492 : : }
1493 : : }
1494 : : } while (wait);
1495 : : }
1496 : : #endif
1497 : :
1498 : 0 : static struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
1499 : : {
1500 : : struct sk_buff *skb;
1501 : : u32 offset;
1502 : :
1503 [ # # ]: 0 : while ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) {
1504 : 0 : offset = seq - TCP_SKB_CB(skb)->seq;
1505 [ # # ]: 0 : if (tcp_hdr(skb)->syn)
1506 : 0 : offset--;
1507 [ # # ][ # # ]: 0 : if (offset < skb->len || tcp_hdr(skb)->fin) {
1508 : 0 : *off = offset;
1509 : 0 : return skb;
1510 : : }
1511 : : /* This looks weird, but this can happen if TCP collapsing
1512 : : * splitted a fat GRO packet, while we released socket lock
1513 : : * in skb_splice_bits()
1514 : : */
1515 : : sk_eat_skb(sk, skb, false);
1516 : : }
1517 : : return NULL;
1518 : : }
1519 : :
1520 : : /*
1521 : : * This routine provides an alternative to tcp_recvmsg() for routines
1522 : : * that would like to handle copying from skbuffs directly in 'sendfile'
1523 : : * fashion.
1524 : : * Note:
1525 : : * - It is assumed that the socket was locked by the caller.
1526 : : * - The routine does not block.
1527 : : * - At present, there is no support for reading OOB data
1528 : : * or for 'peeking' the socket using this routine
1529 : : * (although both would be easy to implement).
1530 : : */
1531 : 0 : int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
1532 : : sk_read_actor_t recv_actor)
1533 : : {
1534 : : struct sk_buff *skb;
1535 : : struct tcp_sock *tp = tcp_sk(sk);
1536 : 0 : u32 seq = tp->copied_seq;
1537 : : u32 offset;
1538 : : int copied = 0;
1539 : :
1540 [ # # ]: 0 : if (sk->sk_state == TCP_LISTEN)
1541 : : return -ENOTCONN;
1542 [ # # ]: 0 : while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
1543 [ # # ]: 0 : if (offset < skb->len) {
1544 : : int used;
1545 : : size_t len;
1546 : :
1547 : 0 : len = skb->len - offset;
1548 : : /* Stop reading if we hit a patch of urgent data */
1549 [ # # ]: 0 : if (tp->urg_data) {
1550 : 0 : u32 urg_offset = tp->urg_seq - seq;
1551 [ # # ]: 0 : if (urg_offset < len)
1552 : : len = urg_offset;
1553 [ # # ]: 0 : if (!len)
1554 : : break;
1555 : : }
1556 : 0 : used = recv_actor(desc, skb, offset, len);
1557 [ # # ]: 0 : if (used <= 0) {
1558 [ # # ]: 0 : if (!copied)
1559 : : copied = used;
1560 : : break;
1561 [ # # ]: 0 : } else if (used <= len) {
1562 : 0 : seq += used;
1563 : 0 : copied += used;
1564 : 0 : offset += used;
1565 : : }
1566 : : /* If recv_actor drops the lock (e.g. TCP splice
1567 : : * receive) the skb pointer might be invalid when
1568 : : * getting here: tcp_collapse might have deleted it
1569 : : * while aggregating skbs from the socket queue.
1570 : : */
1571 : 0 : skb = tcp_recv_skb(sk, seq - 1, &offset);
1572 [ # # ]: 0 : if (!skb)
1573 : : break;
1574 : : /* TCP coalescing might have appended data to the skb.
1575 : : * Try to splice more frags
1576 : : */
1577 [ # # ]: 0 : if (offset + 1 != skb->len)
1578 : 0 : continue;
1579 : : }
1580 [ # # ]: 0 : if (tcp_hdr(skb)->fin) {
1581 : : sk_eat_skb(sk, skb, false);
1582 : 0 : ++seq;
1583 : 0 : break;
1584 : : }
1585 : : sk_eat_skb(sk, skb, false);
1586 [ # # ]: 0 : if (!desc->count)
1587 : : break;
1588 : 0 : tp->copied_seq = seq;
1589 : : }
1590 : 0 : tp->copied_seq = seq;
1591 : :
1592 : 0 : tcp_rcv_space_adjust(sk);
1593 : :
1594 : : /* Clean up data we have read: This will do ACK frames. */
1595 [ # # ]: 0 : if (copied > 0) {
1596 : 0 : tcp_recv_skb(sk, seq, &offset);
1597 : 0 : tcp_cleanup_rbuf(sk, copied);
1598 : : uid_stat_tcp_rcv(from_kuid(&init_user_ns, current_uid()),
1599 : : copied);
1600 : : }
1601 : 0 : return copied;
1602 : : }
1603 : : EXPORT_SYMBOL(tcp_read_sock);
1604 : :
1605 : : /*
1606 : : * This routine copies from a sock struct into the user buffer.
1607 : : *
1608 : : * Technical note: in 2.3 we work on _locked_ socket, so that
1609 : : * tricks with *seq access order and skb->users are not required.
1610 : : * Probably, code can be easily improved even more.
1611 : : */
1612 : :
1613 : 0 : int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1614 : : size_t len, int nonblock, int flags, int *addr_len)
1615 : : {
1616 : : struct tcp_sock *tp = tcp_sk(sk);
1617 : : int copied = 0;
1618 : : u32 peek_seq;
1619 : : u32 *seq;
1620 : : unsigned long used;
1621 : : int err;
1622 : : int target; /* Read at least this many bytes */
1623 : : long timeo;
1624 : : struct task_struct *user_recv = NULL;
1625 : : bool copied_early = false;
1626 : : struct sk_buff *skb;
1627 : : u32 urg_hole = 0;
1628 : :
1629 [ - + ][ # # ]: 18814 : if (sk_can_busy_loop(sk) && skb_queue_empty(&sk->sk_receive_queue) &&
[ # # ]
1630 : 0 : (sk->sk_state == TCP_ESTABLISHED))
1631 : : sk_busy_loop(sk, nonblock);
1632 : :
1633 : : lock_sock(sk);
1634 : :
1635 : : err = -ENOTCONN;
1636 [ + - ]: 18814 : if (sk->sk_state == TCP_LISTEN)
1637 : : goto out;
1638 : :
1639 : 18814 : timeo = sock_rcvtimeo(sk, nonblock);
1640 : :
1641 : : /* Urgent data needs to be handled specially. */
1642 [ + + ]: 18814 : if (flags & MSG_OOB)
1643 : : goto recv_urg;
1644 : :
1645 [ - + ]: 18810 : if (unlikely(tp->repair)) {
1646 : : err = -EPERM;
1647 [ # # ]: 0 : if (!(flags & MSG_PEEK))
1648 : : goto out;
1649 : :
1650 [ # # ]: 0 : if (tp->repair_queue == TCP_SEND_QUEUE)
1651 : : goto recv_sndq;
1652 : :
1653 : : err = -EINVAL;
1654 [ # # ]: 0 : if (tp->repair_queue == TCP_NO_QUEUE)
1655 : : goto out;
1656 : :
1657 : : /* 'common' recv queue MSG_PEEK-ing */
1658 : : }
1659 : :
1660 : 18810 : seq = &tp->copied_seq;
1661 [ - + ]: 18810 : if (flags & MSG_PEEK) {
1662 : 0 : peek_seq = tp->copied_seq;
1663 : : seq = &peek_seq;
1664 : : }
1665 : :
1666 : 18810 : target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1667 : :
1668 : : #ifdef CONFIG_NET_DMA
1669 : : tp->ucopy.dma_chan = NULL;
1670 : : preempt_disable();
1671 : : skb = skb_peek_tail(&sk->sk_receive_queue);
1672 : : {
1673 : : int available = 0;
1674 : :
1675 : : if (skb)
1676 : : available = TCP_SKB_CB(skb)->seq + skb->len - (*seq);
1677 : : if ((available < target) &&
1678 : : (len > sysctl_tcp_dma_copybreak) && !(flags & MSG_PEEK) &&
1679 : : !sysctl_tcp_low_latency &&
1680 : : net_dma_find_channel()) {
1681 : : preempt_enable();
1682 : : tp->ucopy.pinned_list =
1683 : : dma_pin_iovec_pages(msg->msg_iov, len);
1684 : : } else {
1685 : : preempt_enable();
1686 : : }
1687 : : }
1688 : : #endif
1689 : :
1690 : : do {
1691 : : u32 offset;
1692 : :
1693 : : /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
1694 [ - + ][ # # ]: 19165 : if (tp->urg_data && tp->urg_seq == *seq) {
1695 [ # # ]: 0 : if (copied)
1696 : : break;
1697 [ # # ]: 0 : if (signal_pending(current)) {
1698 [ # # ]: 0 : copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
1699 : 0 : break;
1700 : : }
1701 : : }
1702 : :
1703 : : /* Next get a buffer. */
1704 : :
1705 [ + + ]: 19165 : skb_queue_walk(&sk->sk_receive_queue, skb) {
1706 : : /* Now that we have two receive queues this
1707 : : * shouldn't happen.
1708 : : */
1709 [ - + ][ + - ]: 18227 : if (WARN(before(*seq, TCP_SKB_CB(skb)->seq),
1710 : : "recvmsg bug: copied %X seq %X rcvnxt %X fl %X\n",
1711 : : *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
1712 : : flags))
1713 : : break;
1714 : :
1715 : 18227 : offset = *seq - TCP_SKB_CB(skb)->seq;
1716 [ - + ]: 18227 : if (tcp_hdr(skb)->syn)
1717 : 0 : offset--;
1718 [ + + ]: 18227 : if (offset < skb->len)
1719 : : goto found_ok_skb;
1720 [ - + ]: 12 : if (tcp_hdr(skb)->fin)
1721 : : goto found_fin_ok;
1722 [ # # ]: 0 : WARN(!(flags & MSG_PEEK),
1723 : : "recvmsg bug 2: copied %X seq %X rcvnxt %X fl %X\n",
1724 : : *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags);
1725 : : }
1726 : :
1727 : : /* Well, if we have backlog, try to process it now yet. */
1728 : :
1729 [ + + ][ + + ]: 938 : if (copied >= target && !sk->sk_backlog.tail)
1730 : : break;
1731 : :
1732 [ + + ]: 587 : if (copied) {
1733 [ + - ][ + - ]: 1 : if (sk->sk_err ||
1734 [ + - ]: 1 : sk->sk_state == TCP_CLOSE ||
1735 [ - + ]: 1 : (sk->sk_shutdown & RCV_SHUTDOWN) ||
1736 [ # # ]: 0 : !timeo ||
1737 : 0 : signal_pending(current))
1738 : : break;
1739 : : } else {
1740 [ + - ]: 586 : if (sock_flag(sk, SOCK_DONE))
1741 : : break;
1742 : :
1743 [ + + ]: 586 : if (sk->sk_err) {
1744 : : copied = sock_error(sk);
1745 : 9 : break;
1746 : : }
1747 : :
1748 [ + - ]: 577 : if (sk->sk_shutdown & RCV_SHUTDOWN)
1749 : : break;
1750 : :
1751 [ - + ]: 577 : if (sk->sk_state == TCP_CLOSE) {
1752 [ # # ]: 0 : if (!sock_flag(sk, SOCK_DONE)) {
1753 : : /* This occurs when user tries to read
1754 : : * from never connected socket.
1755 : : */
1756 : : copied = -ENOTCONN;
1757 : 0 : break;
1758 : : }
1759 : : break;
1760 : : }
1761 : :
1762 [ + - ]: 577 : if (!timeo) {
1763 : : copied = -EAGAIN;
1764 : : break;
1765 : : }
1766 : :
1767 [ - + ]: 577 : if (signal_pending(current)) {
1768 : : copied = sock_intr_errno(timeo);
1769 : 0 : break;
1770 : : }
1771 : : }
1772 : :
1773 : 577 : tcp_cleanup_rbuf(sk, copied);
1774 : :
1775 [ + - ][ + - ]: 577 : if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
1776 : : /* Install new reader */
1777 [ + - ][ + - ]: 577 : if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
1778 : 577 : user_recv = current;
1779 : 577 : tp->ucopy.task = user_recv;
1780 : 577 : tp->ucopy.iov = msg->msg_iov;
1781 : : }
1782 : :
1783 : 577 : tp->ucopy.len = len;
1784 : :
1785 [ - + ][ # # ]: 577 : WARN_ON(tp->copied_seq != tp->rcv_nxt &&
[ - + ]
1786 : : !(flags & (MSG_PEEK | MSG_TRUNC)));
1787 : :
1788 : : /* Ugly... If prequeue is not empty, we have to
1789 : : * process it before releasing socket, otherwise
1790 : : * order will be broken at second iteration.
1791 : : * More elegant solution is required!!!
1792 : : *
1793 : : * Look: we have the following (pseudo)queues:
1794 : : *
1795 : : * 1. packets in flight
1796 : : * 2. backlog
1797 : : * 3. prequeue
1798 : : * 4. receive_queue
1799 : : *
1800 : : * Each queue can be processed only if the next ones
1801 : : * are empty. At this point we have empty receive_queue.
1802 : : * But prequeue _can_ be not empty after 2nd iteration,
1803 : : * when we jumped to start of loop because backlog
1804 : : * processing added something to receive_queue.
1805 : : * We cannot release_sock(), because backlog contains
1806 : : * packets arrived _after_ prequeued ones.
1807 : : *
1808 : : * Shortly, algorithm is clear --- to process all
1809 : : * the queues in order. We could make it more directly,
1810 : : * requeueing packets from backlog to prequeue, if
1811 : : * is not empty. It is more elegant, but eats cycles,
1812 : : * unfortunately.
1813 : : */
1814 [ + - ]: 577 : if (!skb_queue_empty(&tp->ucopy.prequeue))
1815 : : goto do_prequeue;
1816 : :
1817 : : /* __ Set realtime policy in scheduler __ */
1818 : : }
1819 : :
1820 : : #ifdef CONFIG_NET_DMA
1821 : : if (tp->ucopy.dma_chan) {
1822 : : if (tp->rcv_wnd == 0 &&
1823 : : !skb_queue_empty(&sk->sk_async_wait_queue)) {
1824 : : tcp_service_net_dma(sk, true);
1825 : : tcp_cleanup_rbuf(sk, copied);
1826 : : } else
1827 : : dma_async_issue_pending(tp->ucopy.dma_chan);
1828 : : }
1829 : : #endif
1830 [ - + ]: 577 : if (copied >= target) {
1831 : : /* Do not sleep, just process backlog. */
1832 : 0 : release_sock(sk);
1833 : : lock_sock(sk);
1834 : : } else
1835 : 577 : sk_wait_data(sk, &timeo);
1836 : :
1837 : : #ifdef CONFIG_NET_DMA
1838 : : tcp_service_net_dma(sk, false); /* Don't block */
1839 : : tp->ucopy.wakeup = 0;
1840 : : #endif
1841 : :
1842 [ + - ]: 577 : if (user_recv) {
1843 : : int chunk;
1844 : :
1845 : : /* __ Restore normal policy in scheduler __ */
1846 : :
1847 [ - + ]: 577 : if ((chunk = len - tp->ucopy.len) != 0) {
1848 : 0 : NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);
1849 : 0 : len -= chunk;
1850 : 0 : copied += chunk;
1851 : : }
1852 : :
1853 [ + + ][ + - ]: 577 : if (tp->rcv_nxt == tp->copied_seq &&
1854 : 576 : !skb_queue_empty(&tp->ucopy.prequeue)) {
1855 : : do_prequeue:
1856 : 576 : tcp_prequeue_process(sk);
1857 : :
1858 [ + + ]: 576 : if ((chunk = len - tp->ucopy.len) != 0) {
1859 : 1148 : NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1860 : 574 : len -= chunk;
1861 : 574 : copied += chunk;
1862 : : }
1863 : : }
1864 : : }
1865 [ - + ][ # # ]: 577 : if ((flags & MSG_PEEK) &&
1866 : 0 : (peek_seq - copied - urg_hole != tp->copied_seq)) {
1867 : 0 : net_dbg_ratelimited("TCP(%s:%d): Application bug, race in MSG_PEEK\n",
1868 : : current->comm,
1869 : : task_pid_nr(current));
1870 : 0 : peek_seq = tp->copied_seq;
1871 : : }
1872 : 577 : continue;
1873 : :
1874 : : found_ok_skb:
1875 : : /* Ok so how much can we use? */
1876 : 18215 : used = skb->len - offset;
1877 [ + + ]: 18215 : if (len < used)
1878 : : used = len;
1879 : :
1880 : : /* Do we have urgent data here? */
1881 [ - + ]: 18215 : if (tp->urg_data) {
1882 : 0 : u32 urg_offset = tp->urg_seq - *seq;
1883 [ # # ]: 0 : if (urg_offset < used) {
1884 [ # # ]: 0 : if (!urg_offset) {
1885 [ # # ]: 0 : if (!sock_flag(sk, SOCK_URGINLINE)) {
1886 : 0 : ++*seq;
1887 : 0 : urg_hole++;
1888 : 0 : offset++;
1889 : 0 : used--;
1890 [ # # ]: 0 : if (!used)
1891 : : goto skip_copy;
1892 : : }
1893 : : } else
1894 : : used = urg_offset;
1895 : : }
1896 : : }
1897 : :
1898 [ + - ]: 18215 : if (!(flags & MSG_TRUNC)) {
1899 : : #ifdef CONFIG_NET_DMA
1900 : : if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1901 : : tp->ucopy.dma_chan = net_dma_find_channel();
1902 : :
1903 : : if (tp->ucopy.dma_chan) {
1904 : : tp->ucopy.dma_cookie = dma_skb_copy_datagram_iovec(
1905 : : tp->ucopy.dma_chan, skb, offset,
1906 : : msg->msg_iov, used,
1907 : : tp->ucopy.pinned_list);
1908 : :
1909 : : if (tp->ucopy.dma_cookie < 0) {
1910 : :
1911 : : pr_alert("%s: dma_cookie < 0\n",
1912 : : __func__);
1913 : :
1914 : : /* Exception. Bailout! */
1915 : : if (!copied)
1916 : : copied = -EFAULT;
1917 : : break;
1918 : : }
1919 : :
1920 : : dma_async_issue_pending(tp->ucopy.dma_chan);
1921 : :
1922 : : if ((offset + used) == skb->len)
1923 : : copied_early = true;
1924 : :
1925 : : } else
1926 : : #endif
1927 : : {
1928 : 18215 : err = skb_copy_datagram_iovec(skb, offset,
1929 : : msg->msg_iov, used);
1930 [ + + ]: 18215 : if (err) {
1931 : : /* Exception. Bailout! */
1932 [ + - ]: 3 : if (!copied)
1933 : : copied = -EFAULT;
1934 : : break;
1935 : : }
1936 : : }
1937 : : }
1938 : :
1939 : 18212 : *seq += used;
1940 : 18212 : copied += used;
1941 : 18212 : len -= used;
1942 : :
1943 : 18212 : tcp_rcv_space_adjust(sk);
1944 : :
1945 : : skip_copy:
1946 [ - + ][ # # ]: 18212 : if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
1947 : 0 : tp->urg_data = 0;
1948 : : tcp_fast_path_check(sk);
1949 : : }
1950 [ + + ]: 18212 : if (used + offset < skb->len)
1951 : 17282 : continue;
1952 : :
1953 [ + - ]: 930 : if (tcp_hdr(skb)->fin)
1954 : : goto found_fin_ok;
1955 [ + - ]: 930 : if (!(flags & MSG_PEEK)) {
1956 : : sk_eat_skb(sk, skb, copied_early);
1957 : : copied_early = false;
1958 : : }
1959 : 930 : continue;
1960 : :
1961 : : found_fin_ok:
1962 : : /* Process the FIN. */
1963 : 12 : ++*seq;
1964 [ + - ]: 12 : if (!(flags & MSG_PEEK)) {
1965 : : sk_eat_skb(sk, skb, copied_early);
1966 : : copied_early = false;
1967 : : }
1968 : : break;
1969 [ + + ]: 18789 : } while (len > 0);
1970 : :
1971 [ + + ]: 18810 : if (user_recv) {
1972 [ - + ]: 577 : if (!skb_queue_empty(&tp->ucopy.prequeue)) {
1973 : : int chunk;
1974 : :
1975 [ # # ]: 0 : tp->ucopy.len = copied > 0 ? len : 0;
1976 : :
1977 : 0 : tcp_prequeue_process(sk);
1978 : :
1979 [ # # ][ # # ]: 0 : if (copied > 0 && (chunk = len - tp->ucopy.len) != 0) {
1980 : 0 : NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1981 : : len -= chunk;
1982 : 0 : copied += chunk;
1983 : : }
1984 : : }
1985 : :
1986 : 577 : tp->ucopy.task = NULL;
1987 : 577 : tp->ucopy.len = 0;
1988 : : }
1989 : :
1990 : : #ifdef CONFIG_NET_DMA
1991 : : tcp_service_net_dma(sk, true); /* Wait for queue to drain */
1992 : : tp->ucopy.dma_chan = NULL;
1993 : :
1994 : : if (tp->ucopy.pinned_list) {
1995 : : dma_unpin_iovec_pages(tp->ucopy.pinned_list);
1996 : : tp->ucopy.pinned_list = NULL;
1997 : : }
1998 : : #endif
1999 : :
2000 : : /* According to UNIX98, msg_name/msg_namelen are ignored
2001 : : * on connected socket. I was just happy when found this 8) --ANK
2002 : : */
2003 : :
2004 : : /* Clean up data we have read: This will do ACK frames. */
2005 : 18810 : tcp_cleanup_rbuf(sk, copied);
2006 : :
2007 : 18810 : release_sock(sk);
2008 : :
2009 : : if (copied > 0)
2010 : : uid_stat_tcp_rcv(from_kuid(&init_user_ns, current_uid()),
2011 : : copied);
2012 : 18810 : return copied;
2013 : :
2014 : : out:
2015 : 4 : release_sock(sk);
2016 : 4 : return err;
2017 : :
2018 : : recv_urg:
2019 : 4 : err = tcp_recv_urg(sk, msg, len, flags);
2020 : : if (err > 0)
2021 : : uid_stat_tcp_rcv(from_kuid(&init_user_ns, current_uid()),
2022 : : err);
2023 : 4 : goto out;
2024 : :
2025 : : recv_sndq:
2026 : 0 : err = tcp_peek_sndq(sk, msg, len);
2027 : 0 : goto out;
2028 : : }
2029 : : EXPORT_SYMBOL(tcp_recvmsg);
2030 : :
2031 : 0 : void tcp_set_state(struct sock *sk, int state)
2032 : : {
2033 : 206 : int oldstate = sk->sk_state;
2034 : :
2035 [ + + + ]: 206 : switch (state) {
2036 : : case TCP_ESTABLISHED:
2037 [ + - ]: 52 : if (oldstate != TCP_ESTABLISHED)
2038 : 104 : TCP_INC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
2039 : : break;
2040 : :
2041 : : case TCP_CLOSE:
2042 [ + + ]: 62 : if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
2043 : 40 : TCP_INC_STATS(sock_net(sk), TCP_MIB_ESTABRESETS);
2044 : :
2045 : 62 : sk->sk_prot->unhash(sk);
2046 [ + - ][ + + ]: 62 : if (inet_csk(sk)->icsk_bind_hash &&
2047 : 62 : !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
2048 : 53 : inet_put_port(sk);
2049 : : /* fall through */
2050 : : default:
2051 [ + + ]: 154 : if (oldstate == TCP_ESTABLISHED)
2052 : 104 : TCP_DEC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
2053 : : }
2054 : :
2055 : : /* Change state AFTER socket is unhashed to avoid closed
2056 : : * socket sitting in hash tables.
2057 : : */
2058 : 206 : sk->sk_state = state;
2059 : :
2060 : : #ifdef STATE_TRACE
2061 : : SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n", sk, statename[oldstate], statename[state]);
2062 : : #endif
2063 : 206 : }
2064 : : EXPORT_SYMBOL_GPL(tcp_set_state);
2065 : :
2066 : : /*
2067 : : * State processing on a close. This implements the state shift for
2068 : : * sending our FIN frame. Note that we only send a FIN for some
2069 : : * states. A shutdown() may have already sent the FIN, or we may be
2070 : : * closed.
2071 : : */
2072 : :
2073 : : static const unsigned char new_state[16] = {
2074 : : /* current state: new state: action: */
2075 : : /* (Invalid) */ TCP_CLOSE,
2076 : : /* TCP_ESTABLISHED */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
2077 : : /* TCP_SYN_SENT */ TCP_CLOSE,
2078 : : /* TCP_SYN_RECV */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
2079 : : /* TCP_FIN_WAIT1 */ TCP_FIN_WAIT1,
2080 : : /* TCP_FIN_WAIT2 */ TCP_FIN_WAIT2,
2081 : : /* TCP_TIME_WAIT */ TCP_CLOSE,
2082 : : /* TCP_CLOSE */ TCP_CLOSE,
2083 : : /* TCP_CLOSE_WAIT */ TCP_LAST_ACK | TCP_ACTION_FIN,
2084 : : /* TCP_LAST_ACK */ TCP_LAST_ACK,
2085 : : /* TCP_LISTEN */ TCP_CLOSE,
2086 : : /* TCP_CLOSING */ TCP_CLOSING,
2087 : : };
2088 : :
2089 : : static int tcp_close_state(struct sock *sk)
2090 : : {
2091 : 33 : int next = (int)new_state[sk->sk_state];
2092 : 33 : int ns = next & TCP_STATE_MASK;
2093 : :
2094 : 33 : tcp_set_state(sk, ns);
2095 : :
2096 : 33 : return next & TCP_ACTION_FIN;
2097 : : }
2098 : :
2099 : : /*
2100 : : * Shutdown the sending side of a connection. Much like close except
2101 : : * that we don't receive shut down or sock_set_flag(sk, SOCK_DEAD).
2102 : : */
2103 : :
2104 : 0 : void tcp_shutdown(struct sock *sk, int how)
2105 : : {
2106 : : /* We need to grab some memory, and put together a FIN,
2107 : : * and then put it into the queue to be sent.
2108 : : * Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
2109 : : */
2110 [ + - ]: 3 : if (!(how & SEND_SHUTDOWN))
2111 : 0 : return;
2112 : :
2113 : : /* If we've already sent a FIN, or it's a closed state, skip this. */
2114 [ + - ]: 3 : if ((1 << sk->sk_state) &
2115 : : (TCPF_ESTABLISHED | TCPF_SYN_SENT |
2116 : : TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
2117 : : /* Clear out any half completed packets. FIN if needed. */
2118 [ + - ]: 3 : if (tcp_close_state(sk))
2119 : 3 : tcp_send_fin(sk);
2120 : : }
2121 : : }
2122 : : EXPORT_SYMBOL(tcp_shutdown);
2123 : :
2124 : 0 : bool tcp_check_oom(struct sock *sk, int shift)
2125 : : {
2126 : : bool too_many_orphans, out_of_socket_memory;
2127 : :
2128 : : too_many_orphans = tcp_too_many_orphans(sk, shift);
2129 : : out_of_socket_memory = tcp_out_of_memory(sk);
2130 : :
2131 [ # # ]: 14 : if (too_many_orphans)
2132 [ # # ]: 0 : net_info_ratelimited("too many orphaned sockets\n");
2133 [ - + ]: 14 : if (out_of_socket_memory)
2134 [ # # ]: 0 : net_info_ratelimited("out of memory -- consider tuning tcp_mem\n");
2135 : 14 : return too_many_orphans || out_of_socket_memory;
2136 : : }
2137 : :
2138 : 0 : void tcp_close(struct sock *sk, long timeout)
2139 : : {
2140 : : struct sk_buff *skb;
2141 : : int data_was_unread = 0;
2142 : : int state;
2143 : :
2144 : : lock_sock(sk);
2145 : 104 : sk->sk_shutdown = SHUTDOWN_MASK;
2146 : :
2147 [ + + ]: 104 : if (sk->sk_state == TCP_LISTEN) {
2148 : 9 : tcp_set_state(sk, TCP_CLOSE);
2149 : :
2150 : : /* Special case. */
2151 : 9 : inet_csk_listen_stop(sk);
2152 : :
2153 : 9 : goto adjudge_to_death;
2154 : : }
2155 : :
2156 : : /* We need to flush the recv. buffs. We do this only on the
2157 : : * descriptor close, not protocol-sourced closes, because the
2158 : : * reader process may not have drained the data yet!
2159 : : */
2160 [ + + ]: 111 : while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
2161 : 32 : u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq -
2162 : 16 : tcp_hdr(skb)->fin;
2163 : 16 : data_was_unread += len;
2164 : 16 : __kfree_skb(skb);
2165 : : }
2166 : :
2167 : : sk_mem_reclaim(sk);
2168 : :
2169 : : /* If socket has been already reset (e.g. in tcp_reset()) - kill it. */
2170 [ + + ]: 95 : if (sk->sk_state == TCP_CLOSE)
2171 : : goto adjudge_to_death;
2172 : :
2173 : : /* As outlined in RFC 2525, section 2.17, we send a RST here because
2174 : : * data was lost. To witness the awful effects of the old behavior of
2175 : : * always doing a FIN, run an older 2.1.x kernel or 2.0.x, start a bulk
2176 : : * GET in an FTP client, suspend the process, wait for the client to
2177 : : * advertise a zero window, then kill -9 the FTP client, wheee...
2178 : : * Note: timeout is always zero in such a case.
2179 : : */
2180 [ - + ]: 40 : if (unlikely(tcp_sk(sk)->repair)) {
2181 : 0 : sk->sk_prot->disconnect(sk, 0);
2182 [ + + ]: 40 : } else if (data_was_unread) {
2183 : : /* Unread data was tossed, zap the connection. */
2184 : 20 : NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPABORTONCLOSE);
2185 : 10 : tcp_set_state(sk, TCP_CLOSE);
2186 : 10 : tcp_send_active_reset(sk, sk->sk_allocation);
2187 [ - + ][ # # ]: 30 : } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
2188 : : /* Check zero linger _after_ checking for unread data. */
2189 : 0 : sk->sk_prot->disconnect(sk, 0);
2190 : 0 : NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
2191 [ + + ]: 30 : } else if (tcp_close_state(sk)) {
2192 : : /* We FIN if the application ate all the data before
2193 : : * zapping the connection.
2194 : : */
2195 : :
2196 : : /* RED-PEN. Formally speaking, we have broken TCP state
2197 : : * machine. State transitions:
2198 : : *
2199 : : * TCP_ESTABLISHED -> TCP_FIN_WAIT1
2200 : : * TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
2201 : : * TCP_CLOSE_WAIT -> TCP_LAST_ACK
2202 : : *
2203 : : * are legal only when FIN has been sent (i.e. in window),
2204 : : * rather than queued out of window. Purists blame.
2205 : : *
2206 : : * F.e. "RFC state" is ESTABLISHED,
2207 : : * if Linux state is FIN-WAIT-1, but FIN is still not sent.
2208 : : *
2209 : : * The visible declinations are that sometimes
2210 : : * we enter time-wait state, when it is not required really
2211 : : * (harmless), do not send active resets, when they are
2212 : : * required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
2213 : : * they look as CLOSING or LAST_ACK for Linux)
2214 : : * Probably, I missed some more holelets.
2215 : : * --ANK
2216 : : * XXX (TFO) - To start off we don't support SYN+ACK+FIN
2217 : : * in a single packet! (May consider it later but will
2218 : : * probably need API support or TCP_CORK SYN-ACK until
2219 : : * data is written and socket is closed.)
2220 : : */
2221 : 29 : tcp_send_fin(sk);
2222 : : }
2223 : :
2224 : 40 : sk_stream_wait_close(sk, timeout);
2225 : :
2226 : : adjudge_to_death:
2227 : 104 : state = sk->sk_state;
2228 : : sock_hold(sk);
2229 : : sock_orphan(sk);
2230 : :
2231 : : /* It is the last release_sock in its life. It will remove backlog. */
2232 : 104 : release_sock(sk);
2233 : :
2234 : :
2235 : : /* Now socket is owned by kernel and we acquire BH lock
2236 : : to finish close. No need to check for user refs.
2237 : : */
2238 : : local_bh_disable();
2239 : : bh_lock_sock(sk);
2240 [ - + ]: 104 : WARN_ON(sock_owned_by_user(sk));
2241 : :
2242 : 104 : percpu_counter_inc(sk->sk_prot->orphan_count);
2243 : :
2244 : : /* Have we already been destroyed by a softirq or backlog? */
2245 [ + + ][ + ]: 104 : if (state != TCP_CLOSE && sk->sk_state == TCP_CLOSE)
2246 : : goto out;
2247 : :
2248 : : /* This is a (useful) BSD violating of the RFC. There is a
2249 : : * problem with TCP as specified in that the other end could
2250 : : * keep a socket open forever with no application left this end.
2251 : : * We use a 1 minute timeout (about the same as BSD) then kill
2252 : : * our end. If they send after that then tough - BUT: long enough
2253 : : * that we won't make the old 4*rto = almost no time - whoops
2254 : : * reset mistake.
2255 : : *
2256 : : * Nope, it was not mistake. It is really desired behaviour
2257 : : * f.e. on http servers, when such sockets are useless, but
2258 : : * consume significant resources. Let's do it with special
2259 : : * linger2 option. --ANK
2260 : : */
2261 : :
2262 [ - + ]: 192 : if (sk->sk_state == TCP_FIN_WAIT2) {
2263 : : struct tcp_sock *tp = tcp_sk(sk);
2264 [ # # ]: 0 : if (tp->linger2 < 0) {
2265 : 0 : tcp_set_state(sk, TCP_CLOSE);
2266 : 0 : tcp_send_active_reset(sk, GFP_ATOMIC);
2267 : 0 : NET_INC_STATS_BH(sock_net(sk),
2268 : : LINUX_MIB_TCPABORTONLINGER);
2269 : : } else {
2270 : : const int tmo = tcp_fin_time(sk);
2271 : :
2272 [ # # ]: 0 : if (tmo > TCP_TIMEWAIT_LEN) {
2273 : 0 : inet_csk_reset_keepalive_timer(sk,
2274 : 0 : tmo - TCP_TIMEWAIT_LEN);
2275 : : } else {
2276 : 0 : tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
2277 : 0 : goto out;
2278 : : }
2279 : : }
2280 : : }
2281 [ + + ]: 88 : if (sk->sk_state != TCP_CLOSE) {
2282 : : sk_mem_reclaim(sk);
2283 [ - + ]: 14 : if (tcp_check_oom(sk, 0)) {
2284 : 0 : tcp_set_state(sk, TCP_CLOSE);
2285 : 0 : tcp_send_active_reset(sk, GFP_ATOMIC);
2286 : 0 : NET_INC_STATS_BH(sock_net(sk),
2287 : : LINUX_MIB_TCPABORTONMEMORY);
2288 : : }
2289 : : }
2290 : :
2291 [ + + ]: 88 : if (sk->sk_state == TCP_CLOSE) {
2292 : 74 : struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
2293 : : /* We could get here with a non-NULL req if the socket is
2294 : : * aborted (e.g., closed with unread data) before 3WHS
2295 : : * finishes.
2296 : : */
2297 [ - + ]: 74 : if (req != NULL)
2298 : 0 : reqsk_fastopen_remove(sk, req, false);
2299 : 74 : inet_csk_destroy_sock(sk);
2300 : : }
2301 : : /* Otherwise, socket is reprieved until protocol close. */
2302 : :
2303 : : out:
2304 : : bh_unlock_sock(sk);
2305 : : local_bh_enable();
2306 : : sock_put(sk);
2307 : 104 : }
2308 : : EXPORT_SYMBOL(tcp_close);
2309 : :
2310 : : /* These states need RST on ABORT according to RFC793 */
2311 : :
2312 : : static inline bool tcp_need_reset(int state)
2313 : : {
2314 : 1 : return (1 << state) &
2315 : : (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 |
2316 : : TCPF_FIN_WAIT2 | TCPF_SYN_RECV);
2317 : : }
2318 : :
2319 : 0 : int tcp_disconnect(struct sock *sk, int flags)
2320 : : {
2321 : : struct inet_sock *inet = inet_sk(sk);
2322 : : struct inet_connection_sock *icsk = inet_csk(sk);
2323 : : struct tcp_sock *tp = tcp_sk(sk);
2324 : : int err = 0;
2325 : 1 : int old_state = sk->sk_state;
2326 : :
2327 [ - + ]: 1 : if (old_state != TCP_CLOSE)
2328 : 0 : tcp_set_state(sk, TCP_CLOSE);
2329 : :
2330 : : /* ABORT function of RFC793 */
2331 [ - + ]: 1 : if (old_state == TCP_LISTEN) {
2332 : 0 : inet_csk_listen_stop(sk);
2333 [ - + ]: 1 : } else if (unlikely(tp->repair)) {
2334 : 0 : sk->sk_err = ECONNABORTED;
2335 [ + - ][ - + ]: 1 : } else if (tcp_need_reset(old_state) ||
2336 [ # # ]: 0 : (tp->snd_nxt != tp->write_seq &&
2337 : : (1 << old_state) & (TCPF_CLOSING | TCPF_LAST_ACK))) {
2338 : : /* The last check adjusts for discrepancy of Linux wrt. RFC
2339 : : * states
2340 : : */
2341 : 0 : tcp_send_active_reset(sk, gfp_any());
2342 : 0 : sk->sk_err = ECONNRESET;
2343 [ - + ]: 1 : } else if (old_state == TCP_SYN_SENT)
2344 : 0 : sk->sk_err = ECONNRESET;
2345 : :
2346 : : tcp_clear_xmit_timers(sk);
2347 : 1 : __skb_queue_purge(&sk->sk_receive_queue);
2348 : : tcp_write_queue_purge(sk);
2349 : 1 : __skb_queue_purge(&tp->out_of_order_queue);
2350 : : #ifdef CONFIG_NET_DMA
2351 : : __skb_queue_purge(&sk->sk_async_wait_queue);
2352 : : #endif
2353 : :
2354 : 1 : inet->inet_dport = 0;
2355 : :
2356 [ + - ]: 1 : if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
2357 : : inet_reset_saddr(sk);
2358 : :
2359 : 1 : sk->sk_shutdown = 0;
2360 : : sock_reset_flag(sk, SOCK_DONE);
2361 : 1 : tp->srtt = 0;
2362 [ - + ]: 1 : if ((tp->write_seq += tp->max_window + 2) == 0)
2363 : 0 : tp->write_seq = 1;
2364 : 1 : icsk->icsk_backoff = 0;
2365 : 1 : tp->snd_cwnd = 2;
2366 : 1 : icsk->icsk_probes_out = 0;
2367 : 1 : tp->packets_out = 0;
2368 : 1 : tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
2369 : 1 : tp->snd_cwnd_cnt = 0;
2370 : 1 : tp->window_clamp = 0;
2371 : : tcp_set_ca_state(sk, TCP_CA_Open);
2372 : 1 : tcp_clear_retrans(tp);
2373 : : inet_csk_delack_init(sk);
2374 : : tcp_init_send_head(sk);
2375 : 1 : memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
2376 : : __sk_dst_reset(sk);
2377 : :
2378 [ - + ][ # # ]: 1 : WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
[ - + ]
2379 : :
2380 : 1 : sk->sk_error_report(sk);
2381 : 1 : return err;
2382 : : }
2383 : : EXPORT_SYMBOL(tcp_disconnect);
2384 : :
2385 : 0 : void tcp_sock_destruct(struct sock *sk)
2386 : : {
2387 : 0 : inet_sock_destruct(sk);
2388 : :
2389 : 0 : kfree(inet_csk(sk)->icsk_accept_queue.fastopenq);
2390 : 0 : }
2391 : :
2392 : : static inline bool tcp_can_repair_sock(const struct sock *sk)
2393 : : {
2394 [ # # ][ # # ]: 0 : return ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN) &&
2395 : 0 : ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_ESTABLISHED));
2396 : : }
2397 : :
2398 : 0 : static int tcp_repair_options_est(struct tcp_sock *tp,
2399 : : struct tcp_repair_opt __user *optbuf, unsigned int len)
2400 : : {
2401 : : struct tcp_repair_opt opt;
2402 : :
2403 [ # # ]: 0 : while (len >= sizeof(opt)) {
2404 [ # # ]: 0 : if (copy_from_user(&opt, optbuf, sizeof(opt)))
2405 : : return -EFAULT;
2406 : :
2407 : 0 : optbuf++;
2408 : 0 : len -= sizeof(opt);
2409 : :
2410 [ # # # # : 0 : switch (opt.opt_code) {
# ]
2411 : : case TCPOPT_MSS:
2412 : 0 : tp->rx_opt.mss_clamp = opt.opt_val;
2413 : 0 : break;
2414 : : case TCPOPT_WINDOW:
2415 : : {
2416 : 0 : u16 snd_wscale = opt.opt_val & 0xFFFF;
2417 : 0 : u16 rcv_wscale = opt.opt_val >> 16;
2418 : :
2419 [ # # ]: 0 : if (snd_wscale > 14 || rcv_wscale > 14)
2420 : : return -EFBIG;
2421 : :
2422 : 0 : tp->rx_opt.snd_wscale = snd_wscale;
2423 : 0 : tp->rx_opt.rcv_wscale = rcv_wscale;
2424 : 0 : tp->rx_opt.wscale_ok = 1;
2425 : : }
2426 : 0 : break;
2427 : : case TCPOPT_SACK_PERM:
2428 [ # # ]: 0 : if (opt.opt_val != 0)
2429 : : return -EINVAL;
2430 : :
2431 : 0 : tp->rx_opt.sack_ok |= TCP_SACK_SEEN;
2432 [ # # ]: 0 : if (sysctl_tcp_fack)
2433 : : tcp_enable_fack(tp);
2434 : : break;
2435 : : case TCPOPT_TIMESTAMP:
2436 [ # # ]: 0 : if (opt.opt_val != 0)
2437 : : return -EINVAL;
2438 : :
2439 : 0 : tp->rx_opt.tstamp_ok = 1;
2440 : 0 : break;
2441 : : }
2442 : : }
2443 : :
2444 : : return 0;
2445 : : }
2446 : :
2447 : : /*
2448 : : * Socket option code for TCP.
2449 : : */
2450 : 1 : static int do_tcp_setsockopt(struct sock *sk, int level,
2451 : : int optname, char __user *optval, unsigned int optlen)
2452 : : {
2453 : : struct tcp_sock *tp = tcp_sk(sk);
2454 : : struct inet_connection_sock *icsk = inet_csk(sk);
2455 : : int val;
2456 : : int err = 0;
2457 : :
2458 : : /* These are data/string values, all the others are ints */
2459 [ - + ]: 1 : switch (optname) {
2460 : : case TCP_CONGESTION: {
2461 : : char name[TCP_CA_NAME_MAX];
2462 : :
2463 [ # # ]: 0 : if (optlen < 1)
2464 : : return -EINVAL;
2465 : :
2466 : 0 : val = strncpy_from_user(name, optval,
2467 : 0 : min_t(long, TCP_CA_NAME_MAX-1, optlen));
2468 [ # # ]: 0 : if (val < 0)
2469 : : return -EFAULT;
2470 : 0 : name[val] = 0;
2471 : :
2472 : : lock_sock(sk);
2473 : 0 : err = tcp_set_congestion_control(sk, name);
2474 : 0 : release_sock(sk);
2475 : : return err;
2476 : : }
2477 : : default:
2478 : : /* fallthru */
2479 : : break;
2480 : : }
2481 : :
2482 [ + - ]: 1 : if (optlen < sizeof(int))
2483 : : return -EINVAL;
2484 : :
2485 [ + - ]: 1 : if (get_user(val, (int __user *)optval))
2486 : : return -EFAULT;
2487 : :
2488 : : lock_sock(sk);
2489 : :
2490 [ - - - - : 1 : switch (optname) {
- - - - -
- - - - -
+ - - - -
- - - ]
2491 : : case TCP_MAXSEG:
2492 : : /* Values greater than interface MTU won't take effect. However
2493 : : * at the point when this call is done we typically don't yet
2494 : : * know which interface is going to be used */
2495 [ # # ]: 0 : if (val < TCP_MIN_MSS || val > MAX_TCP_WINDOW) {
2496 : : err = -EINVAL;
2497 : : break;
2498 : : }
2499 : 0 : tp->rx_opt.user_mss = val;
2500 : : break;
2501 : :
2502 : : case TCP_NODELAY:
2503 [ # # ]: 0 : if (val) {
2504 : : /* TCP_NODELAY is weaker than TCP_CORK, so that
2505 : : * this option on corked socket is remembered, but
2506 : : * it is not activated until cork is cleared.
2507 : : *
2508 : : * However, when TCP_NODELAY is set we make
2509 : : * an explicit push, which overrides even TCP_CORK
2510 : : * for currently queued segments.
2511 : : */
2512 : 0 : tp->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH;
2513 : : tcp_push_pending_frames(sk);
2514 : : } else {
2515 : 0 : tp->nonagle &= ~TCP_NAGLE_OFF;
2516 : : }
2517 : : break;
2518 : :
2519 : : case TCP_THIN_LINEAR_TIMEOUTS:
2520 [ # # ]: 0 : if (val < 0 || val > 1)
2521 : : err = -EINVAL;
2522 : : else
2523 : 0 : tp->thin_lto = val;
2524 : : break;
2525 : :
2526 : : case TCP_THIN_DUPACK:
2527 [ # # ]: 0 : if (val < 0 || val > 1)
2528 : : err = -EINVAL;
2529 : : else {
2530 : 0 : tp->thin_dupack = val;
2531 [ # # ]: 0 : if (tp->thin_dupack)
2532 : : tcp_disable_early_retrans(tp);
2533 : : }
2534 : : break;
2535 : :
2536 : : case TCP_REPAIR:
2537 [ # # ]: 0 : if (!tcp_can_repair_sock(sk))
2538 : : err = -EPERM;
2539 [ # # ]: 0 : else if (val == 1) {
2540 : 0 : tp->repair = 1;
2541 : 0 : sk->sk_reuse = SK_FORCE_REUSE;
2542 : 0 : tp->repair_queue = TCP_NO_QUEUE;
2543 [ # # ]: 0 : } else if (val == 0) {
2544 : 0 : tp->repair = 0;
2545 : 0 : sk->sk_reuse = SK_NO_REUSE;
2546 : 0 : tcp_send_window_probe(sk);
2547 : : } else
2548 : : err = -EINVAL;
2549 : :
2550 : : break;
2551 : :
2552 : : case TCP_REPAIR_QUEUE:
2553 [ # # ]: 0 : if (!tp->repair)
2554 : : err = -EPERM;
2555 [ # # ]: 0 : else if (val < TCP_QUEUES_NR)
2556 : 0 : tp->repair_queue = val;
2557 : : else
2558 : : err = -EINVAL;
2559 : : break;
2560 : :
2561 : : case TCP_QUEUE_SEQ:
2562 [ # # ]: 0 : if (sk->sk_state != TCP_CLOSE)
2563 : : err = -EPERM;
2564 [ # # ]: 0 : else if (tp->repair_queue == TCP_SEND_QUEUE)
2565 : 0 : tp->write_seq = val;
2566 [ # # ]: 0 : else if (tp->repair_queue == TCP_RECV_QUEUE)
2567 : 0 : tp->rcv_nxt = val;
2568 : : else
2569 : : err = -EINVAL;
2570 : : break;
2571 : :
2572 : : case TCP_REPAIR_OPTIONS:
2573 [ # # ]: 0 : if (!tp->repair)
2574 : : err = -EINVAL;
2575 [ # # ]: 0 : else if (sk->sk_state == TCP_ESTABLISHED)
2576 : 0 : err = tcp_repair_options_est(tp,
2577 : : (struct tcp_repair_opt __user *)optval,
2578 : : optlen);
2579 : : else
2580 : : err = -EPERM;
2581 : : break;
2582 : :
2583 : : case TCP_CORK:
2584 : : /* When set indicates to always queue non-full frames.
2585 : : * Later the user clears this option and we transmit
2586 : : * any pending partial frames in the queue. This is
2587 : : * meant to be used alongside sendfile() to get properly
2588 : : * filled frames when the user (for example) must write
2589 : : * out headers with a write() call first and then use
2590 : : * sendfile to send out the data parts.
2591 : : *
2592 : : * TCP_CORK can be set together with TCP_NODELAY and it is
2593 : : * stronger than TCP_NODELAY.
2594 : : */
2595 [ # # ]: 0 : if (val) {
2596 : 0 : tp->nonagle |= TCP_NAGLE_CORK;
2597 : : } else {
2598 : 0 : tp->nonagle &= ~TCP_NAGLE_CORK;
2599 [ # # ]: 0 : if (tp->nonagle&TCP_NAGLE_OFF)
2600 : 0 : tp->nonagle |= TCP_NAGLE_PUSH;
2601 : : tcp_push_pending_frames(sk);
2602 : : }
2603 : : break;
2604 : :
2605 : : case TCP_KEEPIDLE:
2606 [ # # ]: 0 : if (val < 1 || val > MAX_TCP_KEEPIDLE)
2607 : : err = -EINVAL;
2608 : : else {
2609 : 0 : tp->keepalive_time = val * HZ;
2610 [ # # ][ # # ]: 0 : if (sock_flag(sk, SOCK_KEEPOPEN) &&
2611 : 0 : !((1 << sk->sk_state) &
2612 : : (TCPF_CLOSE | TCPF_LISTEN))) {
2613 : : u32 elapsed = keepalive_time_elapsed(tp);
2614 [ # # ]: 0 : if (tp->keepalive_time > elapsed)
2615 : 0 : elapsed = tp->keepalive_time - elapsed;
2616 : : else
2617 : : elapsed = 0;
2618 : 0 : inet_csk_reset_keepalive_timer(sk, elapsed);
2619 : : }
2620 : : }
2621 : : break;
2622 : : case TCP_KEEPINTVL:
2623 [ # # ]: 0 : if (val < 1 || val > MAX_TCP_KEEPINTVL)
2624 : : err = -EINVAL;
2625 : : else
2626 : 0 : tp->keepalive_intvl = val * HZ;
2627 : : break;
2628 : : case TCP_KEEPCNT:
2629 [ # # ]: 0 : if (val < 1 || val > MAX_TCP_KEEPCNT)
2630 : : err = -EINVAL;
2631 : : else
2632 : 0 : tp->keepalive_probes = val;
2633 : : break;
2634 : : case TCP_SYNCNT:
2635 [ # # ]: 0 : if (val < 1 || val > MAX_TCP_SYNCNT)
2636 : : err = -EINVAL;
2637 : : else
2638 : 0 : icsk->icsk_syn_retries = val;
2639 : : break;
2640 : :
2641 : : case TCP_LINGER2:
2642 [ # # ]: 0 : if (val < 0)
2643 : 0 : tp->linger2 = -1;
2644 [ # # ]: 0 : else if (val > sysctl_tcp_fin_timeout / HZ)
2645 : 0 : tp->linger2 = 0;
2646 : : else
2647 : 0 : tp->linger2 = val * HZ;
2648 : : break;
2649 : :
2650 : : case TCP_DEFER_ACCEPT:
2651 : : /* Translate value in seconds to number of retransmits */
2652 : 0 : icsk->icsk_accept_queue.rskq_defer_accept =
2653 : : secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ,
2654 : : TCP_RTO_MAX / HZ);
2655 : : break;
2656 : :
2657 : : case TCP_WINDOW_CLAMP:
2658 [ # # ]: 0 : if (!val) {
2659 [ # # ]: 0 : if (sk->sk_state != TCP_CLOSE) {
2660 : : err = -EINVAL;
2661 : : break;
2662 : : }
2663 : 0 : tp->window_clamp = 0;
2664 : : } else
2665 : 0 : tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
2666 : 0 : SOCK_MIN_RCVBUF / 2 : val;
2667 : : break;
2668 : :
2669 : : case TCP_QUICKACK:
2670 [ # # ]: 0 : if (!val) {
2671 : 0 : icsk->icsk_ack.pingpong = 1;
2672 : : } else {
2673 : 0 : icsk->icsk_ack.pingpong = 0;
2674 [ # # ]: 0 : if ((1 << sk->sk_state) &
2675 [ # # ]: 0 : (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
2676 : : inet_csk_ack_scheduled(sk)) {
2677 : 0 : icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
2678 : 0 : tcp_cleanup_rbuf(sk, 1);
2679 [ # # ]: 0 : if (!(val & 1))
2680 : 0 : icsk->icsk_ack.pingpong = 1;
2681 : : }
2682 : : }
2683 : : break;
2684 : :
2685 : : #ifdef CONFIG_TCP_MD5SIG
2686 : : case TCP_MD5SIG:
2687 : : /* Read the IP->Key mappings from userspace */
2688 : : err = tp->af_specific->md5_parse(sk, optval, optlen);
2689 : : break;
2690 : : #endif
2691 : : case TCP_USER_TIMEOUT:
2692 : : /* Cap the max timeout in ms TCP will retry/retrans
2693 : : * before giving up and aborting (ETIMEDOUT) a connection.
2694 : : */
2695 [ # # ]: 0 : if (val < 0)
2696 : : err = -EINVAL;
2697 : : else
2698 : 0 : icsk->icsk_user_timeout = msecs_to_jiffies(val);
2699 : : break;
2700 : :
2701 : : case TCP_FASTOPEN:
2702 [ # # ][ # # ]: 0 : if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE |
2703 : : TCPF_LISTEN)))
2704 : : err = fastopen_init_queue(sk, val);
2705 : : else
2706 : : err = -EINVAL;
2707 : : break;
2708 : : case TCP_TIMESTAMP:
2709 [ # # ]: 0 : if (!tp->repair)
2710 : : err = -EPERM;
2711 : : else
2712 : 0 : tp->tsoffset = val - tcp_time_stamp;
2713 : : break;
2714 : : case TCP_NOTSENT_LOWAT:
2715 : 0 : tp->notsent_lowat = val;
2716 : 0 : sk->sk_write_space(sk);
2717 : : break;
2718 : : default:
2719 : : err = -ENOPROTOOPT;
2720 : : break;
2721 : : }
2722 : :
2723 : 0 : release_sock(sk);
2724 : : return err;
2725 : : }
2726 : :
2727 : 0 : int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
2728 : : unsigned int optlen)
2729 : : {
2730 : : const struct inet_connection_sock *icsk = inet_csk(sk);
2731 : :
2732 [ + + ]: 4 : if (level != SOL_TCP)
2733 : 3 : return icsk->icsk_af_ops->setsockopt(sk, level, optname,
2734 : : optval, optlen);
2735 : 1 : return do_tcp_setsockopt(sk, level, optname, optval, optlen);
2736 : : }
2737 : : EXPORT_SYMBOL(tcp_setsockopt);
2738 : :
2739 : : #ifdef CONFIG_COMPAT
2740 : : int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
2741 : : char __user *optval, unsigned int optlen)
2742 : : {
2743 : : if (level != SOL_TCP)
2744 : : return inet_csk_compat_setsockopt(sk, level, optname,
2745 : : optval, optlen);
2746 : : return do_tcp_setsockopt(sk, level, optname, optval, optlen);
2747 : : }
2748 : : EXPORT_SYMBOL(compat_tcp_setsockopt);
2749 : : #endif
2750 : :
2751 : : /* Return information about state of tcp endpoint in API format. */
2752 : 0 : void tcp_get_info(const struct sock *sk, struct tcp_info *info)
2753 : : {
2754 : : const struct tcp_sock *tp = tcp_sk(sk);
2755 : : const struct inet_connection_sock *icsk = inet_csk(sk);
2756 : 0 : u32 now = tcp_time_stamp;
2757 : :
2758 : 0 : memset(info, 0, sizeof(*info));
2759 : :
2760 : 0 : info->tcpi_state = sk->sk_state;
2761 : 0 : info->tcpi_ca_state = icsk->icsk_ca_state;
2762 : 0 : info->tcpi_retransmits = icsk->icsk_retransmits;
2763 : 0 : info->tcpi_probes = icsk->icsk_probes_out;
2764 : 0 : info->tcpi_backoff = icsk->icsk_backoff;
2765 : :
2766 [ # # ]: 0 : if (tp->rx_opt.tstamp_ok)
2767 : 0 : info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
2768 [ # # ]: 0 : if (tcp_is_sack(tp))
2769 : 0 : info->tcpi_options |= TCPI_OPT_SACK;
2770 [ # # ]: 0 : if (tp->rx_opt.wscale_ok) {
2771 : 0 : info->tcpi_options |= TCPI_OPT_WSCALE;
2772 : 0 : info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
2773 : 0 : info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
2774 : : }
2775 : :
2776 [ # # ]: 0 : if (tp->ecn_flags & TCP_ECN_OK)
2777 : 0 : info->tcpi_options |= TCPI_OPT_ECN;
2778 [ # # ]: 0 : if (tp->ecn_flags & TCP_ECN_SEEN)
2779 : 0 : info->tcpi_options |= TCPI_OPT_ECN_SEEN;
2780 [ # # ]: 0 : if (tp->syn_data_acked)
2781 : 0 : info->tcpi_options |= TCPI_OPT_SYN_DATA;
2782 : :
2783 : 0 : info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto);
2784 : 0 : info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato);
2785 : 0 : info->tcpi_snd_mss = tp->mss_cache;
2786 : 0 : info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss;
2787 : :
2788 [ # # ]: 0 : if (sk->sk_state == TCP_LISTEN) {
2789 : 0 : info->tcpi_unacked = sk->sk_ack_backlog;
2790 : 0 : info->tcpi_sacked = sk->sk_max_ack_backlog;
2791 : : } else {
2792 : 0 : info->tcpi_unacked = tp->packets_out;
2793 : 0 : info->tcpi_sacked = tp->sacked_out;
2794 : : }
2795 : 0 : info->tcpi_lost = tp->lost_out;
2796 : 0 : info->tcpi_retrans = tp->retrans_out;
2797 : 0 : info->tcpi_fackets = tp->fackets_out;
2798 : :
2799 : 0 : info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
2800 : 0 : info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime);
2801 : 0 : info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
2802 : :
2803 : 0 : info->tcpi_pmtu = icsk->icsk_pmtu_cookie;
2804 : 0 : info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
2805 : 0 : info->tcpi_rtt = jiffies_to_usecs(tp->srtt)>>3;
2806 : 0 : info->tcpi_rttvar = jiffies_to_usecs(tp->mdev)>>2;
2807 : 0 : info->tcpi_snd_ssthresh = tp->snd_ssthresh;
2808 : 0 : info->tcpi_snd_cwnd = tp->snd_cwnd;
2809 : 0 : info->tcpi_advmss = tp->advmss;
2810 : 0 : info->tcpi_reordering = tp->reordering;
2811 : :
2812 : 0 : info->tcpi_rcv_rtt = jiffies_to_usecs(tp->rcv_rtt_est.rtt)>>3;
2813 : 0 : info->tcpi_rcv_space = tp->rcvq_space.space;
2814 : :
2815 : 0 : info->tcpi_total_retrans = tp->total_retrans;
2816 : 0 : }
2817 : : EXPORT_SYMBOL_GPL(tcp_get_info);
2818 : :
2819 : 1 : static int do_tcp_getsockopt(struct sock *sk, int level,
2820 : : int optname, char __user *optval, int __user *optlen)
2821 : : {
2822 : : struct inet_connection_sock *icsk = inet_csk(sk);
2823 : : struct tcp_sock *tp = tcp_sk(sk);
2824 : : int val, len;
2825 : :
2826 [ + - ]: 1 : if (get_user(len, optlen))
2827 : : return -EFAULT;
2828 : :
2829 : 1 : len = min_t(unsigned int, len, sizeof(int));
2830 : :
2831 [ + - ]: 1 : if (len < 0)
2832 : : return -EINVAL;
2833 : :
2834 [ - - - - : 1 : switch (optname) {
- - - - -
- - - - -
- - - - -
- - + ]
2835 : : case TCP_MAXSEG:
2836 : 0 : val = tp->mss_cache;
2837 [ # # ][ # # ]: 0 : if (!val && ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
2838 : 0 : val = tp->rx_opt.user_mss;
2839 [ # # ]: 0 : if (tp->repair)
2840 : 0 : val = tp->rx_opt.mss_clamp;
2841 : : break;
2842 : : case TCP_NODELAY:
2843 : 0 : val = !!(tp->nonagle&TCP_NAGLE_OFF);
2844 : : break;
2845 : : case TCP_CORK:
2846 : 0 : val = !!(tp->nonagle&TCP_NAGLE_CORK);
2847 : : break;
2848 : : case TCP_KEEPIDLE:
2849 : 0 : val = keepalive_time_when(tp) / HZ;
2850 : : break;
2851 : : case TCP_KEEPINTVL:
2852 : 0 : val = keepalive_intvl_when(tp) / HZ;
2853 : : break;
2854 : : case TCP_KEEPCNT:
2855 : 0 : val = keepalive_probes(tp);
2856 : : break;
2857 : : case TCP_SYNCNT:
2858 [ # # ]: 0 : val = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
2859 : : break;
2860 : : case TCP_LINGER2:
2861 : 0 : val = tp->linger2;
2862 [ # # ]: 0 : if (val >= 0)
2863 [ # # ]: 0 : val = (val ? : sysctl_tcp_fin_timeout) / HZ;
2864 : : break;
2865 : : case TCP_DEFER_ACCEPT:
2866 : 0 : val = retrans_to_secs(icsk->icsk_accept_queue.rskq_defer_accept,
2867 : : TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
2868 : : break;
2869 : : case TCP_WINDOW_CLAMP:
2870 : 0 : val = tp->window_clamp;
2871 : : break;
2872 : : case TCP_INFO: {
2873 : : struct tcp_info info;
2874 : :
2875 [ # # ]: 0 : if (get_user(len, optlen))
2876 : : return -EFAULT;
2877 : :
2878 : 0 : tcp_get_info(sk, &info);
2879 : :
2880 : 0 : len = min_t(unsigned int, len, sizeof(info));
2881 [ # # ]: 0 : if (put_user(len, optlen))
2882 : : return -EFAULT;
2883 [ # # ]: 0 : if (copy_to_user(optval, &info, len))
2884 : : return -EFAULT;
2885 : : return 0;
2886 : : }
2887 : : case TCP_QUICKACK:
2888 : 0 : val = !icsk->icsk_ack.pingpong;
2889 : : break;
2890 : :
2891 : : case TCP_CONGESTION:
2892 [ # # ]: 0 : if (get_user(len, optlen))
2893 : : return -EFAULT;
2894 : 0 : len = min_t(unsigned int, len, TCP_CA_NAME_MAX);
2895 [ # # ]: 0 : if (put_user(len, optlen))
2896 : : return -EFAULT;
2897 [ # # ]: 0 : if (copy_to_user(optval, icsk->icsk_ca_ops->name, len))
2898 : : return -EFAULT;
2899 : : return 0;
2900 : :
2901 : : case TCP_THIN_LINEAR_TIMEOUTS:
2902 : 0 : val = tp->thin_lto;
2903 : : break;
2904 : : case TCP_THIN_DUPACK:
2905 : 0 : val = tp->thin_dupack;
2906 : : break;
2907 : :
2908 : : case TCP_REPAIR:
2909 : 0 : val = tp->repair;
2910 : : break;
2911 : :
2912 : : case TCP_REPAIR_QUEUE:
2913 [ # # ]: 0 : if (tp->repair)
2914 : 0 : val = tp->repair_queue;
2915 : : else
2916 : : return -EINVAL;
2917 : : break;
2918 : :
2919 : : case TCP_QUEUE_SEQ:
2920 [ # # ]: 0 : if (tp->repair_queue == TCP_SEND_QUEUE)
2921 : 0 : val = tp->write_seq;
2922 [ # # ]: 0 : else if (tp->repair_queue == TCP_RECV_QUEUE)
2923 : 0 : val = tp->rcv_nxt;
2924 : : else
2925 : : return -EINVAL;
2926 : : break;
2927 : :
2928 : : case TCP_USER_TIMEOUT:
2929 : 0 : val = jiffies_to_msecs(icsk->icsk_user_timeout);
2930 : : break;
2931 : : case TCP_TIMESTAMP:
2932 : 0 : val = tcp_time_stamp + tp->tsoffset;
2933 : : break;
2934 : : case TCP_NOTSENT_LOWAT:
2935 : 0 : val = tp->notsent_lowat;
2936 : : break;
2937 : : default:
2938 : : return -ENOPROTOOPT;
2939 : : }
2940 : :
2941 [ # # ]: 0 : if (put_user(len, optlen))
2942 : : return -EFAULT;
2943 [ # # ]: 0 : if (copy_to_user(optval, &val, len))
2944 : : return -EFAULT;
2945 : : return 0;
2946 : : }
2947 : :
2948 : 0 : int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
2949 : : int __user *optlen)
2950 : : {
2951 : : struct inet_connection_sock *icsk = inet_csk(sk);
2952 : :
2953 [ + + ]: 5 : if (level != SOL_TCP)
2954 : 4 : return icsk->icsk_af_ops->getsockopt(sk, level, optname,
2955 : : optval, optlen);
2956 : 1 : return do_tcp_getsockopt(sk, level, optname, optval, optlen);
2957 : : }
2958 : : EXPORT_SYMBOL(tcp_getsockopt);
2959 : :
2960 : : #ifdef CONFIG_COMPAT
2961 : : int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
2962 : : char __user *optval, int __user *optlen)
2963 : : {
2964 : : if (level != SOL_TCP)
2965 : : return inet_csk_compat_getsockopt(sk, level, optname,
2966 : : optval, optlen);
2967 : : return do_tcp_getsockopt(sk, level, optname, optval, optlen);
2968 : : }
2969 : : EXPORT_SYMBOL(compat_tcp_getsockopt);
2970 : : #endif
2971 : :
2972 : : #ifdef CONFIG_TCP_MD5SIG
2973 : : static struct tcp_md5sig_pool __percpu *tcp_md5sig_pool __read_mostly;
2974 : : static DEFINE_MUTEX(tcp_md5sig_mutex);
2975 : :
2976 : : static void __tcp_free_md5sig_pool(struct tcp_md5sig_pool __percpu *pool)
2977 : : {
2978 : : int cpu;
2979 : :
2980 : : for_each_possible_cpu(cpu) {
2981 : : struct tcp_md5sig_pool *p = per_cpu_ptr(pool, cpu);
2982 : :
2983 : : if (p->md5_desc.tfm)
2984 : : crypto_free_hash(p->md5_desc.tfm);
2985 : : }
2986 : : free_percpu(pool);
2987 : : }
2988 : :
2989 : : static void __tcp_alloc_md5sig_pool(void)
2990 : : {
2991 : : int cpu;
2992 : : struct tcp_md5sig_pool __percpu *pool;
2993 : :
2994 : : pool = alloc_percpu(struct tcp_md5sig_pool);
2995 : : if (!pool)
2996 : : return;
2997 : :
2998 : : for_each_possible_cpu(cpu) {
2999 : : struct crypto_hash *hash;
3000 : :
3001 : : hash = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
3002 : : if (IS_ERR_OR_NULL(hash))
3003 : : goto out_free;
3004 : :
3005 : : per_cpu_ptr(pool, cpu)->md5_desc.tfm = hash;
3006 : : }
3007 : : /* before setting tcp_md5sig_pool, we must commit all writes
3008 : : * to memory. See ACCESS_ONCE() in tcp_get_md5sig_pool()
3009 : : */
3010 : : smp_wmb();
3011 : : tcp_md5sig_pool = pool;
3012 : : return;
3013 : : out_free:
3014 : : __tcp_free_md5sig_pool(pool);
3015 : : }
3016 : :
3017 : : bool tcp_alloc_md5sig_pool(void)
3018 : : {
3019 : : if (unlikely(!tcp_md5sig_pool)) {
3020 : : mutex_lock(&tcp_md5sig_mutex);
3021 : :
3022 : : if (!tcp_md5sig_pool)
3023 : : __tcp_alloc_md5sig_pool();
3024 : :
3025 : : mutex_unlock(&tcp_md5sig_mutex);
3026 : : }
3027 : : return tcp_md5sig_pool != NULL;
3028 : : }
3029 : : EXPORT_SYMBOL(tcp_alloc_md5sig_pool);
3030 : :
3031 : :
3032 : : /**
3033 : : * tcp_get_md5sig_pool - get md5sig_pool for this user
3034 : : *
3035 : : * We use percpu structure, so if we succeed, we exit with preemption
3036 : : * and BH disabled, to make sure another thread or softirq handling
3037 : : * wont try to get same context.
3038 : : */
3039 : : struct tcp_md5sig_pool *tcp_get_md5sig_pool(void)
3040 : : {
3041 : : struct tcp_md5sig_pool __percpu *p;
3042 : :
3043 : : local_bh_disable();
3044 : : p = ACCESS_ONCE(tcp_md5sig_pool);
3045 : : if (p)
3046 : : return __this_cpu_ptr(p);
3047 : :
3048 : : local_bh_enable();
3049 : : return NULL;
3050 : : }
3051 : : EXPORT_SYMBOL(tcp_get_md5sig_pool);
3052 : :
3053 : : int tcp_md5_hash_header(struct tcp_md5sig_pool *hp,
3054 : : const struct tcphdr *th)
3055 : : {
3056 : : struct scatterlist sg;
3057 : : struct tcphdr hdr;
3058 : : int err;
3059 : :
3060 : : /* We are not allowed to change tcphdr, make a local copy */
3061 : : memcpy(&hdr, th, sizeof(hdr));
3062 : : hdr.check = 0;
3063 : :
3064 : : /* options aren't included in the hash */
3065 : : sg_init_one(&sg, &hdr, sizeof(hdr));
3066 : : err = crypto_hash_update(&hp->md5_desc, &sg, sizeof(hdr));
3067 : : return err;
3068 : : }
3069 : : EXPORT_SYMBOL(tcp_md5_hash_header);
3070 : :
3071 : : int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *hp,
3072 : : const struct sk_buff *skb, unsigned int header_len)
3073 : : {
3074 : : struct scatterlist sg;
3075 : : const struct tcphdr *tp = tcp_hdr(skb);
3076 : : struct hash_desc *desc = &hp->md5_desc;
3077 : : unsigned int i;
3078 : : const unsigned int head_data_len = skb_headlen(skb) > header_len ?
3079 : : skb_headlen(skb) - header_len : 0;
3080 : : const struct skb_shared_info *shi = skb_shinfo(skb);
3081 : : struct sk_buff *frag_iter;
3082 : :
3083 : : sg_init_table(&sg, 1);
3084 : :
3085 : : sg_set_buf(&sg, ((u8 *) tp) + header_len, head_data_len);
3086 : : if (crypto_hash_update(desc, &sg, head_data_len))
3087 : : return 1;
3088 : :
3089 : : for (i = 0; i < shi->nr_frags; ++i) {
3090 : : const struct skb_frag_struct *f = &shi->frags[i];
3091 : : unsigned int offset = f->page_offset;
3092 : : struct page *page = skb_frag_page(f) + (offset >> PAGE_SHIFT);
3093 : :
3094 : : sg_set_page(&sg, page, skb_frag_size(f),
3095 : : offset_in_page(offset));
3096 : : if (crypto_hash_update(desc, &sg, skb_frag_size(f)))
3097 : : return 1;
3098 : : }
3099 : :
3100 : : skb_walk_frags(skb, frag_iter)
3101 : : if (tcp_md5_hash_skb_data(hp, frag_iter, 0))
3102 : : return 1;
3103 : :
3104 : : return 0;
3105 : : }
3106 : : EXPORT_SYMBOL(tcp_md5_hash_skb_data);
3107 : :
3108 : : int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, const struct tcp_md5sig_key *key)
3109 : : {
3110 : : struct scatterlist sg;
3111 : :
3112 : : sg_init_one(&sg, key->key, key->keylen);
3113 : : return crypto_hash_update(&hp->md5_desc, &sg, key->keylen);
3114 : : }
3115 : : EXPORT_SYMBOL(tcp_md5_hash_key);
3116 : :
3117 : : #endif
3118 : :
3119 : 0 : void tcp_done(struct sock *sk)
3120 : : {
3121 : 43 : struct request_sock *req = tcp_sk(sk)->fastopen_rsk;
3122 : :
3123 [ + + ][ - + ]: 43 : if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
3124 : 1 : TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
3125 : :
3126 : 43 : tcp_set_state(sk, TCP_CLOSE);
3127 : : tcp_clear_xmit_timers(sk);
3128 [ - + ]: 43 : if (req != NULL)
3129 : 0 : reqsk_fastopen_remove(sk, req, false);
3130 : :
3131 : 43 : sk->sk_shutdown = SHUTDOWN_MASK;
3132 : :
3133 [ + + ]: 43 : if (!sock_flag(sk, SOCK_DEAD))
3134 : 13 : sk->sk_state_change(sk);
3135 : : else
3136 : 30 : inet_csk_destroy_sock(sk);
3137 : 43 : }
3138 : : EXPORT_SYMBOL_GPL(tcp_done);
3139 : :
3140 : : extern struct tcp_congestion_ops tcp_reno;
3141 : :
3142 : : static __initdata unsigned long thash_entries;
3143 : 0 : static int __init set_thash_entries(char *str)
3144 : : {
3145 : : ssize_t ret;
3146 : :
3147 [ # # ]: 0 : if (!str)
3148 : : return 0;
3149 : :
3150 : : ret = kstrtoul(str, 0, &thash_entries);
3151 [ # # ]: 0 : if (ret)
3152 : : return 0;
3153 : :
3154 : 0 : return 1;
3155 : : }
3156 : : __setup("thash_entries=", set_thash_entries);
3157 : :
3158 : 0 : static void tcp_init_mem(void)
3159 : : {
3160 : 0 : unsigned long limit = nr_free_buffer_pages() / 8;
3161 : 0 : limit = max(limit, 128UL);
3162 : 0 : sysctl_tcp_mem[0] = limit / 4 * 3;
3163 : 0 : sysctl_tcp_mem[1] = limit;
3164 : 0 : sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;
3165 : 0 : }
3166 : :
3167 : 0 : void __init tcp_init(void)
3168 : : {
3169 : : struct sk_buff *skb = NULL;
3170 : : unsigned long limit;
3171 : : int max_rshare, max_wshare, cnt;
3172 : : unsigned int i;
3173 : :
3174 : : BUILD_BUG_ON(sizeof(struct tcp_skb_cb) > sizeof(skb->cb));
3175 : :
3176 : 0 : percpu_counter_init(&tcp_sockets_allocated, 0);
3177 : 0 : percpu_counter_init(&tcp_orphan_count, 0);
3178 : 0 : tcp_hashinfo.bind_bucket_cachep =
3179 : 0 : kmem_cache_create("tcp_bind_bucket",
3180 : : sizeof(struct inet_bind_bucket), 0,
3181 : : SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
3182 : :
3183 : : /* Size and allocate the main established and bind bucket
3184 : : * hash tables.
3185 : : *
3186 : : * The methodology is similar to that of the buffer cache.
3187 : : */
3188 : 0 : tcp_hashinfo.ehash =
3189 [ # # ]: 0 : alloc_large_system_hash("TCP established",
3190 : : sizeof(struct inet_ehash_bucket),
3191 : : thash_entries,
3192 : : 17, /* one slot per 128 KB of memory */
3193 : : 0,
3194 : : NULL,
3195 : : &tcp_hashinfo.ehash_mask,
3196 : : 0,
3197 : 0 : thash_entries ? 0 : 512 * 1024);
3198 [ # # ]: 0 : for (i = 0; i <= tcp_hashinfo.ehash_mask; i++)
3199 : 0 : INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);
3200 : :
3201 [ # # ]: 0 : if (inet_ehash_locks_alloc(&tcp_hashinfo))
3202 : 0 : panic("TCP: failed to alloc ehash_locks");
3203 : 0 : tcp_hashinfo.bhash =
3204 : 0 : alloc_large_system_hash("TCP bind",
3205 : : sizeof(struct inet_bind_hashbucket),
3206 : 0 : tcp_hashinfo.ehash_mask + 1,
3207 : : 17, /* one slot per 128 KB of memory */
3208 : : 0,
3209 : : &tcp_hashinfo.bhash_size,
3210 : : NULL,
3211 : : 0,
3212 : : 64 * 1024);
3213 : 0 : tcp_hashinfo.bhash_size = 1U << tcp_hashinfo.bhash_size;
3214 [ # # ]: 0 : for (i = 0; i < tcp_hashinfo.bhash_size; i++) {
3215 : 0 : spin_lock_init(&tcp_hashinfo.bhash[i].lock);
3216 : 0 : INIT_HLIST_HEAD(&tcp_hashinfo.bhash[i].chain);
3217 : : }
3218 : :
3219 : :
3220 : 0 : cnt = tcp_hashinfo.ehash_mask + 1;
3221 : :
3222 : 0 : tcp_death_row.sysctl_max_tw_buckets = cnt / 2;
3223 : 0 : sysctl_tcp_max_orphans = cnt / 2;
3224 : 0 : sysctl_max_syn_backlog = max(128, cnt / 256);
3225 : :
3226 : 0 : tcp_init_mem();
3227 : : /* Set per-socket limits to no more than 1/128 the pressure threshold */
3228 : 0 : limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);
3229 : 0 : max_wshare = min(4UL*1024*1024, limit);
3230 : 0 : max_rshare = min(6UL*1024*1024, limit);
3231 : :
3232 : 0 : sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
3233 : 0 : sysctl_tcp_wmem[1] = 16*1024;
3234 : 0 : sysctl_tcp_wmem[2] = max(64*1024, max_wshare);
3235 : :
3236 : 0 : sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;
3237 : 0 : sysctl_tcp_rmem[1] = 87380;
3238 : 0 : sysctl_tcp_rmem[2] = max(87380, max_rshare);
3239 : :
3240 : 0 : pr_info("Hash tables configured (established %u bind %u)\n",
3241 : : tcp_hashinfo.ehash_mask + 1, tcp_hashinfo.bhash_size);
3242 : :
3243 : 0 : tcp_metrics_init();
3244 : :
3245 : 0 : tcp_register_congestion_control(&tcp_reno);
3246 : :
3247 : 0 : tcp_tasklet_init();
3248 : 0 : }
3249 : :
3250 : 0 : static int tcp_is_local(struct net *net, __be32 addr) {
3251 : : struct rtable *rt;
3252 : 0 : struct flowi4 fl4 = { .daddr = addr };
3253 : : rt = ip_route_output_key(net, &fl4);
3254 [ # # ]: 0 : if (IS_ERR_OR_NULL(rt))
3255 : : return 0;
3256 [ # # ][ # # ]: 0 : return rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK);
3257 : : }
3258 : :
3259 : : #if defined(CONFIG_IPV6)
3260 : 0 : static int tcp_is_local6(struct net *net, struct in6_addr *addr) {
3261 : 0 : struct rt6_info *rt6 = rt6_lookup(net, addr, addr, 0, 0);
3262 [ # # ][ # # ]: 0 : return rt6 && rt6->dst.dev && (rt6->dst.dev->flags & IFF_LOOPBACK);
[ # # ]
3263 : : }
3264 : : #endif
3265 : :
3266 : : /*
3267 : : * tcp_nuke_addr - destroy all sockets on the given local address
3268 : : * if local address is the unspecified address (0.0.0.0 or ::), destroy all
3269 : : * sockets with local addresses that are not configured.
3270 : : */
3271 : 0 : int tcp_nuke_addr(struct net *net, struct sockaddr *addr)
3272 : : {
3273 : 0 : int family = addr->sa_family;
3274 : : unsigned int bucket;
3275 : :
3276 : : struct in_addr *in;
3277 : : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3278 : : struct in6_addr *in6 = NULL;
3279 : : #endif
3280 [ # # ]: 0 : if (family == AF_INET) {
3281 : 0 : in = &((struct sockaddr_in *)addr)->sin_addr;
3282 : : #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3283 [ # # ]: 0 : } else if (family == AF_INET6) {
3284 : 0 : in6 = &((struct sockaddr_in6 *)addr)->sin6_addr;
3285 : : #endif
3286 : : } else {
3287 : : return -EAFNOSUPPORT;
3288 : : }
3289 : :
3290 [ # # ]: 0 : for (bucket = 0; bucket < tcp_hashinfo.ehash_mask; bucket++) {
3291 : : struct hlist_nulls_node *node;
3292 : : struct sock *sk;
3293 : 0 : spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, bucket);
3294 : :
3295 : : restart:
3296 : : spin_lock_bh(lock);
3297 [ # # ]: 0 : sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[bucket].chain) {
3298 : : struct inet_sock *inet = inet_sk(sk);
3299 : :
3300 [ # # ][ # # ]: 0 : if (sysctl_ip_dynaddr && sk->sk_state == TCP_SYN_SENT)
3301 : 0 : continue;
3302 [ # # ]: 0 : if (sock_flag(sk, SOCK_DEAD))
3303 : 0 : continue;
3304 : :
3305 [ # # ]: 0 : if (family == AF_INET) {
3306 : 0 : __be32 s4 = inet->inet_rcv_saddr;
3307 [ # # ]: 0 : if (s4 == LOOPBACK4_IPV6)
3308 : 0 : continue;
3309 : :
3310 [ # # ][ # # ]: 0 : if (in->s_addr != s4 &&
3311 [ # # ]: 0 : !(in->s_addr == INADDR_ANY &&
3312 : 0 : !tcp_is_local(net, s4)))
3313 : 0 : continue;
3314 : : }
3315 : :
3316 : : #if defined(CONFIG_IPV6)
3317 [ # # ]: 0 : if (family == AF_INET6) {
3318 : : struct in6_addr *s6;
3319 : :
3320 : 0 : s6 = &sk->sk_v6_rcv_saddr;
3321 [ # # ]: 0 : if (ipv6_addr_type(s6) == IPV6_ADDR_MAPPED)
3322 : 0 : continue;
3323 : :
3324 [ # # ][ # # ]: 0 : if (!ipv6_addr_equal(in6, s6) &&
3325 [ # # ]: 0 : !(ipv6_addr_equal(in6, &in6addr_any) &&
3326 : 0 : !tcp_is_local6(net, s6)))
3327 : 0 : continue;
3328 : : }
3329 : : #endif
3330 : :
3331 : : sock_hold(sk);
3332 : : spin_unlock_bh(lock);
3333 : :
3334 : : local_bh_disable();
3335 : : bh_lock_sock(sk);
3336 : 0 : sk->sk_err = ETIMEDOUT;
3337 : 0 : sk->sk_error_report(sk);
3338 : :
3339 : 0 : tcp_done(sk);
3340 : : bh_unlock_sock(sk);
3341 : : local_bh_enable();
3342 : : sock_put(sk);
3343 : :
3344 : : goto restart;
3345 : : }
3346 : : spin_unlock_bh(lock);
3347 : : }
3348 : :
3349 : : return 0;
3350 : : }
|
