source: src/linux/universal/linux-3.18/net/ipv4/tcp.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 2 months ago

update

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