Branch data Line data Source code
1 : : /*
2 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
3 : : * operating system. INET is implemented using the BSD Socket
4 : : * interface as the means of communication with the user level.
5 : : *
6 : : * Implementation of the Transmission Control Protocol(TCP).
7 : : *
8 : : * Authors: Ross Biro
9 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 : : * Mark Evans, <evansmp@uhura.aston.ac.uk>
11 : : * Corey Minyard <wf-rch!minyard@relay.EU.net>
12 : : * Florian La Roche, <flla@stud.uni-sb.de>
13 : : * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
14 : : * Linus Torvalds, <torvalds@cs.helsinki.fi>
15 : : * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 : : * Matthew Dillon, <dillon@apollo.west.oic.com>
17 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
18 : : * Jorge Cwik, <jorge@laser.satlink.net>
19 : : */
20 : :
21 : : /*
22 : : * Changes: Pedro Roque : Retransmit queue handled by TCP.
23 : : * : Fragmentation on mtu decrease
24 : : * : Segment collapse on retransmit
25 : : * : AF independence
26 : : *
27 : : * Linus Torvalds : send_delayed_ack
28 : : * David S. Miller : Charge memory using the right skb
29 : : * during syn/ack processing.
30 : : * David S. Miller : Output engine completely rewritten.
31 : : * Andrea Arcangeli: SYNACK carry ts_recent in tsecr.
32 : : * Cacophonix Gaul : draft-minshall-nagle-01
33 : : * J Hadi Salim : ECN support
34 : : *
35 : : */
36 : :
37 : : #define pr_fmt(fmt) "TCP: " fmt
38 : :
39 : : #include <net/tcp.h>
40 : :
41 : : #include <linux/compiler.h>
42 : : #include <linux/gfp.h>
43 : : #include <linux/module.h>
44 : :
45 : : /* People can turn this off for buggy TCP's found in printers etc. */
46 : : int sysctl_tcp_retrans_collapse __read_mostly = 1;
47 : :
48 : : /* People can turn this on to work with those rare, broken TCPs that
49 : : * interpret the window field as a signed quantity.
50 : : */
51 : : int sysctl_tcp_workaround_signed_windows __read_mostly = 0;
52 : :
53 : : /* Default TSQ limit of two TSO segments */
54 : : int sysctl_tcp_limit_output_bytes __read_mostly = 131072;
55 : :
56 : : /* This limits the percentage of the congestion window which we
57 : : * will allow a single TSO frame to consume. Building TSO frames
58 : : * which are too large can cause TCP streams to be bursty.
59 : : */
60 : : int sysctl_tcp_tso_win_divisor __read_mostly = 3;
61 : :
62 : : int sysctl_tcp_mtu_probing __read_mostly = 0;
63 : : int sysctl_tcp_base_mss __read_mostly = TCP_BASE_MSS;
64 : :
65 : : /* By default, RFC2861 behavior. */
66 : : int sysctl_tcp_slow_start_after_idle __read_mostly = 1;
67 : :
68 : : unsigned int sysctl_tcp_notsent_lowat __read_mostly = UINT_MAX;
69 : : EXPORT_SYMBOL(sysctl_tcp_notsent_lowat);
70 : :
71 : : static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
72 : : int push_one, gfp_t gfp);
73 : :
74 : : /* Account for new data that has been sent to the network. */
75 : 0 : static void tcp_event_new_data_sent(struct sock *sk, const struct sk_buff *skb)
76 : : {
77 : : struct inet_connection_sock *icsk = inet_csk(sk);
78 : : struct tcp_sock *tp = tcp_sk(sk);
79 : 41626 : unsigned int prior_packets = tp->packets_out;
80 : :
81 : : tcp_advance_send_head(sk, skb);
82 : 41626 : tp->snd_nxt = TCP_SKB_CB(skb)->end_seq;
83 : :
84 : 41626 : tp->packets_out += tcp_skb_pcount(skb);
85 [ + + ][ + - ]: 41626 : if (!prior_packets || icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
[ + + ]
86 : : icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
87 : 41585 : tcp_rearm_rto(sk);
88 : : }
89 : 41626 : }
90 : :
91 : : /* SND.NXT, if window was not shrunk.
92 : : * If window has been shrunk, what should we make? It is not clear at all.
93 : : * Using SND.UNA we will fail to open window, SND.NXT is out of window. :-(
94 : : * Anything in between SND.UNA...SND.UNA+SND.WND also can be already
95 : : * invalid. OK, let's make this for now:
96 : : */
97 : : static inline __u32 tcp_acceptable_seq(const struct sock *sk)
98 : : {
99 : : const struct tcp_sock *tp = tcp_sk(sk);
100 : :
101 [ - + ][ - + ]: 12749 : if (!before(tcp_wnd_end(tp), tp->snd_nxt))
102 : : return tp->snd_nxt;
103 : : else
104 : : return tcp_wnd_end(tp);
105 : : }
106 : :
107 : : /* Calculate mss to advertise in SYN segment.
108 : : * RFC1122, RFC1063, draft-ietf-tcpimpl-pmtud-01 state that:
109 : : *
110 : : * 1. It is independent of path mtu.
111 : : * 2. Ideally, it is maximal possible segment size i.e. 65535-40.
112 : : * 3. For IPv4 it is reasonable to calculate it from maximal MTU of
113 : : * attached devices, because some buggy hosts are confused by
114 : : * large MSS.
115 : : * 4. We do not make 3, we advertise MSS, calculated from first
116 : : * hop device mtu, but allow to raise it to ip_rt_min_advmss.
117 : : * This may be overridden via information stored in routing table.
118 : : * 5. Value 65535 for MSS is valid in IPv6 and means "as large as possible,
119 : : * probably even Jumbo".
120 : : */
121 : 0 : static __u16 tcp_advertise_mss(struct sock *sk)
122 : : {
123 : : struct tcp_sock *tp = tcp_sk(sk);
124 : : const struct dst_entry *dst = __sk_dst_get(sk);
125 : 30 : int mss = tp->advmss;
126 : :
127 [ + - ]: 30 : if (dst) {
128 : : unsigned int metric = dst_metric_advmss(dst);
129 : :
130 [ - + ]: 60 : if (metric < mss) {
131 : 0 : mss = metric;
132 : 0 : tp->advmss = mss;
133 : : }
134 : : }
135 : :
136 : 30 : return (__u16)mss;
137 : : }
138 : :
139 : : /* RFC2861. Reset CWND after idle period longer RTO to "restart window".
140 : : * This is the first part of cwnd validation mechanism. */
141 : 0 : static void tcp_cwnd_restart(struct sock *sk, const struct dst_entry *dst)
142 : : {
143 : : struct tcp_sock *tp = tcp_sk(sk);
144 : 4213 : s32 delta = tcp_time_stamp - tp->lsndtime;
145 : 4213 : u32 restart_cwnd = tcp_init_cwnd(tp, dst);
146 : 4213 : u32 cwnd = tp->snd_cwnd;
147 : :
148 : : tcp_ca_event(sk, CA_EVENT_CWND_RESTART);
149 : :
150 : 4213 : tp->snd_ssthresh = tcp_current_ssthresh(sk);
151 : 4213 : restart_cwnd = min(restart_cwnd, cwnd);
152 : :
153 [ + + ][ + + ]: 4265 : while ((delta -= inet_csk(sk)->icsk_rto) > 0 && cwnd > restart_cwnd)
154 : 52 : cwnd >>= 1;
155 : 4213 : tp->snd_cwnd = max(cwnd, restart_cwnd);
156 : 4213 : tp->snd_cwnd_stamp = tcp_time_stamp;
157 : 4213 : tp->snd_cwnd_used = 0;
158 : 4213 : }
159 : :
160 : : /* Congestion state accounting after a packet has been sent. */
161 : 0 : static void tcp_event_data_sent(struct tcp_sock *tp,
162 : : struct sock *sk)
163 : : {
164 : : struct inet_connection_sock *icsk = inet_csk(sk);
165 : 41620 : const u32 now = tcp_time_stamp;
166 : : const struct dst_entry *dst = __sk_dst_get(sk);
167 : :
168 [ + + ][ + + ]: 41620 : if (sysctl_tcp_slow_start_after_idle &&
169 [ + + ]: 20129 : (!tp->packets_out && (s32)(now - tp->lsndtime) > icsk->icsk_rto))
170 : 4213 : tcp_cwnd_restart(sk, __sk_dst_get(sk));
171 : :
172 : 41620 : tp->lsndtime = now;
173 : :
174 : : /* If it is a reply for ato after last received
175 : : * packet, enter pingpong mode.
176 : : */
177 [ + + ][ + + ]: 41620 : if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk->icsk_ack.ato &&
178 [ + - ]: 4309 : (!dst || !dst_metric(dst, RTAX_QUICKACK)))
179 : 4311 : icsk->icsk_ack.pingpong = 1;
180 : 0 : }
181 : :
182 : : /* Account for an ACK we sent. */
183 : : static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts)
184 : : {
185 : : tcp_dec_quickack_mode(sk, pkts);
186 : : inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
187 : : }
188 : :
189 : :
190 : 0 : u32 tcp_default_init_rwnd(u32 mss)
191 : : {
192 : : /* Initial receive window should be twice of TCP_INIT_CWND to
193 : : * enable proper sending of new unsent data during fast recovery
194 : : * (RFC 3517, Section 4, NextSeg() rule (2)). Further place a
195 : : * limit when mss is larger than 1460.
196 : : */
197 : : u32 init_rwnd = TCP_INIT_CWND * 2;
198 : :
199 [ + + ][ + + ]: 115 : if (mss > 1460)
200 : 110 : init_rwnd = max((1460 * init_rwnd) / mss, 2U);
201 : 0 : return init_rwnd;
202 : : }
203 : :
204 : : /* Determine a window scaling and initial window to offer.
205 : : * Based on the assumption that the given amount of space
206 : : * will be offered. Store the results in the tp structure.
207 : : * NOTE: for smooth operation initial space offering should
208 : : * be a multiple of mss if possible. We assume here that mss >= 1.
209 : : * This MUST be enforced by all callers.
210 : : */
211 : 0 : void tcp_select_initial_window(int __space, __u32 mss,
212 : : __u32 *rcv_wnd, __u32 *window_clamp,
213 : : int wscale_ok, __u8 *rcv_wscale,
214 : : __u32 init_rcv_wnd)
215 : : {
216 : 58 : unsigned int space = (__space < 0 ? 0 : __space);
217 : :
218 : : /* If no clamp set the clamp to the max possible scaled window */
219 [ + - ]: 58 : if (*window_clamp == 0)
220 : 58 : (*window_clamp) = (65535 << 14);
221 : 58 : space = min(*window_clamp, space);
222 : :
223 : : /* Quantize space offering to a multiple of mss if possible. */
224 [ + + ]: 58 : if (space > mss)
225 : 5 : space = (space / mss) * mss;
226 : :
227 : : /* NOTE: offering an initial window larger than 32767
228 : : * will break some buggy TCP stacks. If the admin tells us
229 : : * it is likely we could be speaking with such a buggy stack
230 : : * we will truncate our initial window offering to 32K-1
231 : : * unless the remote has sent us a window scaling option,
232 : : * which we interpret as a sign the remote TCP is not
233 : : * misinterpreting the window field as a signed quantity.
234 : : */
235 [ - + ]: 58 : if (sysctl_tcp_workaround_signed_windows)
236 : 0 : (*rcv_wnd) = min(space, MAX_TCP_WINDOW);
237 : : else
238 : 58 : (*rcv_wnd) = space;
239 : :
240 : 58 : (*rcv_wscale) = 0;
241 [ + - ]: 58 : if (wscale_ok) {
242 : : /* Set window scaling on max possible window
243 : : * See RFC1323 for an explanation of the limit to 14
244 : : */
245 : 58 : space = max_t(u32, sysctl_tcp_rmem[2], sysctl_rmem_max);
246 : 58 : space = min_t(u32, space, *window_clamp);
247 [ + + ][ + - ]: 464 : while (space > 65535 && (*rcv_wscale) < 14) {
248 : 406 : space >>= 1;
249 : 406 : (*rcv_wscale)++;
250 : : }
251 : : }
252 : :
253 [ + ]: 58 : if (mss > (1 << *rcv_wscale)) {
254 [ + - ]: 116 : if (!init_rcv_wnd) /* Use default unless specified otherwise */
255 : : init_rcv_wnd = tcp_default_init_rwnd(mss);
256 : 58 : *rcv_wnd = min(*rcv_wnd, init_rcv_wnd * mss);
257 : : }
258 : :
259 : : /* Set the clamp no higher than max representable value */
260 : 0 : (*window_clamp) = min(65535U << (*rcv_wscale), *window_clamp);
261 : 0 : }
262 : : EXPORT_SYMBOL(tcp_select_initial_window);
263 : :
264 : : /* Chose a new window to advertise, update state in tcp_sock for the
265 : : * socket, and return result with RFC1323 scaling applied. The return
266 : : * value can be stuffed directly into th->window for an outgoing
267 : : * frame.
268 : : */
269 : 0 : static u16 tcp_select_window(struct sock *sk)
270 : : {
271 : : struct tcp_sock *tp = tcp_sk(sk);
272 : : u32 cur_win = tcp_receive_window(tp);
273 : 54440 : u32 new_win = __tcp_select_window(sk);
274 : :
275 : : /* Never shrink the offered window */
276 [ + + ]: 108878 : if (new_win < cur_win) {
277 : : /* Danger Will Robinson!
278 : : * Don't update rcv_wup/rcv_wnd here or else
279 : : * we will not be able to advertise a zero
280 : : * window in time. --DaveM
281 : : *
282 : : * Relax Will Robinson.
283 : : */
284 : 2821 : new_win = ALIGN(cur_win, 1 << tp->rx_opt.rcv_wscale);
285 : : }
286 : 54438 : tp->rcv_wnd = new_win;
287 : 54438 : tp->rcv_wup = tp->rcv_nxt;
288 : :
289 : : /* Make sure we do not exceed the maximum possible
290 : : * scaled window.
291 : : */
292 [ - + ][ # # ]: 54438 : if (!tp->rx_opt.rcv_wscale && sysctl_tcp_workaround_signed_windows)
293 : 0 : new_win = min(new_win, MAX_TCP_WINDOW);
294 : : else
295 : 54438 : new_win = min(new_win, (65535U << tp->rx_opt.rcv_wscale));
296 : :
297 : : /* RFC1323 scaling applied */
298 : 54438 : new_win >>= tp->rx_opt.rcv_wscale;
299 : :
300 : : /* If we advertise zero window, disable fast path. */
301 [ - + ]: 54438 : if (new_win == 0)
302 : 0 : tp->pred_flags = 0;
303 : :
304 : 54438 : return new_win;
305 : : }
306 : :
307 : : /* Packet ECN state for a SYN-ACK */
308 : : static inline void TCP_ECN_send_synack(const struct tcp_sock *tp, struct sk_buff *skb)
309 : : {
310 : 0 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_CWR;
311 [ # # ]: 0 : if (!(tp->ecn_flags & TCP_ECN_OK))
312 : 0 : TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ECE;
313 : : }
314 : :
315 : : /* Packet ECN state for a SYN. */
316 : : static inline void TCP_ECN_send_syn(struct sock *sk, struct sk_buff *skb)
317 : : {
318 : : struct tcp_sock *tp = tcp_sk(sk);
319 : :
320 : 30 : tp->ecn_flags = 0;
321 [ - + ]: 30 : if (sock_net(sk)->ipv4.sysctl_tcp_ecn == 1) {
322 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
323 : 0 : tp->ecn_flags = TCP_ECN_OK;
324 : : }
325 : : }
326 : :
327 : : static __inline__ void
328 : : TCP_ECN_make_synack(const struct request_sock *req, struct tcphdr *th)
329 : : {
330 [ - + ]: 28 : if (inet_rsk(req)->ecn_ok)
331 : 0 : th->ece = 1;
332 : : }
333 : :
334 : : /* Set up ECN state for a packet on a ESTABLISHED socket that is about to
335 : : * be sent.
336 : : */
337 : 0 : static inline void TCP_ECN_send(struct sock *sk, struct sk_buff *skb,
338 : : int tcp_header_len)
339 : : {
340 : : struct tcp_sock *tp = tcp_sk(sk);
341 : :
342 [ - + ]: 54440 : if (tp->ecn_flags & TCP_ECN_OK) {
343 : : /* Not-retransmitted data segment: set ECT and inject CWR. */
344 [ # # ][ # # ]: 0 : if (skb->len != tcp_header_len &&
345 : 0 : !before(TCP_SKB_CB(skb)->seq, tp->snd_nxt)) {
346 : : INET_ECN_xmit(sk);
347 [ # # ]: 0 : if (tp->ecn_flags & TCP_ECN_QUEUE_CWR) {
348 : 0 : tp->ecn_flags &= ~TCP_ECN_QUEUE_CWR;
349 : 0 : tcp_hdr(skb)->cwr = 1;
350 : 0 : skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
351 : : }
352 : : } else {
353 : : /* ACK or retransmitted segment: clear ECT|CE */
354 : : INET_ECN_dontxmit(sk);
355 : : }
356 [ # # ]: 0 : if (tp->ecn_flags & TCP_ECN_DEMAND_CWR)
357 : 0 : tcp_hdr(skb)->ece = 1;
358 : : }
359 : : }
360 : :
361 : : /* Constructs common control bits of non-data skb. If SYN/FIN is present,
362 : : * auto increment end seqno.
363 : : */
364 : 38634 : static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags)
365 : : {
366 : 12878 : skb->ip_summed = CHECKSUM_PARTIAL;
367 : 12878 : skb->csum = 0;
368 : :
369 : 12878 : TCP_SKB_CB(skb)->tcp_flags = flags;
370 : 12878 : TCP_SKB_CB(skb)->sacked = 0;
371 : :
372 : 12878 : skb_shinfo(skb)->gso_segs = 1;
373 : 12878 : skb_shinfo(skb)->gso_size = 0;
374 : 12878 : skb_shinfo(skb)->gso_type = 0;
375 : :
376 : 12878 : TCP_SKB_CB(skb)->seq = seq;
377 : : if (flags & (TCPHDR_SYN | TCPHDR_FIN))
378 : 61 : seq++;
379 : 12878 : TCP_SKB_CB(skb)->end_seq = seq;
380 : : }
381 : :
382 : : static inline bool tcp_urg_mode(const struct tcp_sock *tp)
383 : : {
384 : 95539 : return tp->snd_una != tp->snd_up;
385 : : }
386 : :
387 : : #define OPTION_SACK_ADVERTISE (1 << 0)
388 : : #define OPTION_TS (1 << 1)
389 : : #define OPTION_MD5 (1 << 2)
390 : : #define OPTION_WSCALE (1 << 3)
391 : : #define OPTION_FAST_OPEN_COOKIE (1 << 8)
392 : :
393 : : struct tcp_out_options {
394 : : u16 options; /* bit field of OPTION_* */
395 : : u16 mss; /* 0 to disable */
396 : : u8 ws; /* window scale, 0 to disable */
397 : : u8 num_sack_blocks; /* number of SACK blocks to include */
398 : : u8 hash_size; /* bytes in hash_location */
399 : : __u8 *hash_location; /* temporary pointer, overloaded */
400 : : __u32 tsval, tsecr; /* need to include OPTION_TS */
401 : : struct tcp_fastopen_cookie *fastopen_cookie; /* Fast open cookie */
402 : : };
403 : :
404 : : /* Write previously computed TCP options to the packet.
405 : : *
406 : : * Beware: Something in the Internet is very sensitive to the ordering of
407 : : * TCP options, we learned this through the hard way, so be careful here.
408 : : * Luckily we can at least blame others for their non-compliance but from
409 : : * inter-operatibility perspective it seems that we're somewhat stuck with
410 : : * the ordering which we have been using if we want to keep working with
411 : : * those broken things (not that it currently hurts anybody as there isn't
412 : : * particular reason why the ordering would need to be changed).
413 : : *
414 : : * At least SACK_PERM as the first option is known to lead to a disaster
415 : : * (but it may well be that other scenarios fail similarly).
416 : : */
417 : 0 : static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
418 : : struct tcp_out_options *opts)
419 : : {
420 : 54497 : u16 options = opts->options; /* mungable copy */
421 : :
422 [ - + ]: 54497 : if (unlikely(OPTION_MD5 & options)) {
423 : 0 : *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
424 : : (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
425 : : /* overload cookie hash location */
426 : 0 : opts->hash_location = (__u8 *)ptr;
427 : 0 : ptr += 4;
428 : : }
429 : :
430 [ + + ]: 54497 : if (unlikely(opts->mss)) {
431 [ - + ]: 116 : *ptr++ = htonl((TCPOPT_MSS << 24) |
432 : : (TCPOLEN_MSS << 16) |
433 : : opts->mss);
434 : : }
435 : :
436 [ + - ]: 54497 : if (likely(OPTION_TS & options)) {
437 [ + + ]: 54497 : if (unlikely(OPTION_SACK_ADVERTISE & options)) {
438 : 57 : *ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
439 : : (TCPOLEN_SACK_PERM << 16) |
440 : : (TCPOPT_TIMESTAMP << 8) |
441 : : TCPOLEN_TIMESTAMP);
442 : 57 : options &= ~OPTION_SACK_ADVERTISE;
443 : : } else {
444 : 54440 : *ptr++ = htonl((TCPOPT_NOP << 24) |
445 : : (TCPOPT_NOP << 16) |
446 : : (TCPOPT_TIMESTAMP << 8) |
447 : : TCPOLEN_TIMESTAMP);
448 : : }
449 [ + + ]: 54497 : *ptr++ = htonl(opts->tsval);
450 [ + + ]: 108993 : *ptr++ = htonl(opts->tsecr);
451 : : }
452 : :
453 [ - + ]: 54497 : if (unlikely(OPTION_SACK_ADVERTISE & options)) {
454 : 0 : *ptr++ = htonl((TCPOPT_NOP << 24) |
455 : : (TCPOPT_NOP << 16) |
456 : : (TCPOPT_SACK_PERM << 8) |
457 : : TCPOLEN_SACK_PERM);
458 : : }
459 : :
460 [ + + ]: 54497 : if (unlikely(OPTION_WSCALE & options)) {
461 [ - + ]: 116 : *ptr++ = htonl((TCPOPT_NOP << 24) |
462 : : (TCPOPT_WINDOW << 16) |
463 : : (TCPOLEN_WINDOW << 8) |
464 : : opts->ws);
465 : : }
466 : :
467 [ + ]: 54497 : if (unlikely(opts->num_sack_blocks)) {
468 : 3724 : struct tcp_sack_block *sp = tp->rx_opt.dsack ?
469 [ - + ]: 58221 : tp->duplicate_sack : tp->selective_acks;
470 : : int this_sack;
471 : :
472 [ - + ]: 3724 : *ptr++ = htonl((TCPOPT_NOP << 24) |
473 : : (TCPOPT_NOP << 16) |
474 : : (TCPOPT_SACK << 8) |
475 : : (TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
476 : : TCPOLEN_SACK_PERBLOCK)));
477 : :
478 [ + + ]: 7718 : for (this_sack = 0; this_sack < opts->num_sack_blocks;
479 : 3994 : ++this_sack) {
480 [ - + ]: 3994 : *ptr++ = htonl(sp[this_sack].start_seq);
481 [ - + ]: 3994 : *ptr++ = htonl(sp[this_sack].end_seq);
482 : : }
483 : :
484 : 3724 : tp->rx_opt.dsack = 0;
485 : : }
486 : :
487 [ # # ]: 0 : if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
488 : 0 : struct tcp_fastopen_cookie *foc = opts->fastopen_cookie;
489 : :
490 [ # # ]: 0 : *ptr++ = htonl((TCPOPT_EXP << 24) |
491 : : ((TCPOLEN_EXP_FASTOPEN_BASE + foc->len) << 16) |
492 : : TCPOPT_FASTOPEN_MAGIC);
493 : :
494 : 0 : memcpy(ptr, foc->val, foc->len);
495 [ # # ]: 0 : if ((foc->len & 3) == 2) {
496 : 0 : u8 *align = ((u8 *)ptr) + foc->len;
497 : 0 : align[0] = align[1] = TCPOPT_NOP;
498 : : }
499 : : ptr += (foc->len + 3) >> 2;
500 : : }
501 : 0 : }
502 : :
503 : : /* Compute TCP options for SYN packets. This is not the final
504 : : * network wire format yet.
505 : : */
506 : 0 : static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
507 : : struct tcp_out_options *opts,
508 : : struct tcp_md5sig_key **md5)
509 : : {
510 : : struct tcp_sock *tp = tcp_sk(sk);
511 : : unsigned int remaining = MAX_TCP_OPTION_SPACE;
512 : 30 : struct tcp_fastopen_request *fastopen = tp->fastopen_req;
513 : :
514 : : #ifdef CONFIG_TCP_MD5SIG
515 : : *md5 = tp->af_specific->md5_lookup(sk, sk);
516 : : if (*md5) {
517 : : opts->options |= OPTION_MD5;
518 : : remaining -= TCPOLEN_MD5SIG_ALIGNED;
519 : : }
520 : : #else
521 : 30 : *md5 = NULL;
522 : : #endif
523 : :
524 : : /* We always get an MSS option. The option bytes which will be seen in
525 : : * normal data packets should timestamps be used, must be in the MSS
526 : : * advertised. But we subtract them from tp->mss_cache so that
527 : : * calculations in tcp_sendmsg are simpler etc. So account for this
528 : : * fact here if necessary. If we don't do this correctly, as a
529 : : * receiver we won't recognize data packets as being full sized when we
530 : : * should, and thus we won't abide by the delayed ACK rules correctly.
531 : : * SACKs don't matter, we never delay an ACK when we have any of those
532 : : * going out. */
533 : 30 : opts->mss = tcp_advertise_mss(sk);
534 : : remaining -= TCPOLEN_MSS_ALIGNED;
535 : :
536 [ + - ][ + - ]: 30 : if (likely(sysctl_tcp_timestamps && *md5 == NULL)) {
537 : 30 : opts->options |= OPTION_TS;
538 : 30 : opts->tsval = TCP_SKB_CB(skb)->when + tp->tsoffset;
539 : 30 : opts->tsecr = tp->rx_opt.ts_recent;
540 : : remaining -= TCPOLEN_TSTAMP_ALIGNED;
541 : : }
542 [ + - ]: 30 : if (likely(sysctl_tcp_window_scaling)) {
543 : 30 : opts->ws = tp->rx_opt.rcv_wscale;
544 : 30 : opts->options |= OPTION_WSCALE;
545 : 30 : remaining -= TCPOLEN_WSCALE_ALIGNED;
546 : : }
547 [ + ]: 30 : if (likely(sysctl_tcp_sack)) {
548 : 30 : opts->options |= OPTION_SACK_ADVERTISE;
549 [ - + ]: 30 : if (unlikely(!(OPTION_TS & opts->options)))
550 : 0 : remaining -= TCPOLEN_SACKPERM_ALIGNED;
551 : : }
552 : :
553 [ # # ][ # # ]: 0 : if (fastopen && fastopen->cookie.len >= 0) {
554 : 0 : u32 need = TCPOLEN_EXP_FASTOPEN_BASE + fastopen->cookie.len;
555 : 0 : need = (need + 3) & ~3U; /* Align to 32 bits */
556 [ # # ]: 0 : if (remaining >= need) {
557 : 0 : opts->options |= OPTION_FAST_OPEN_COOKIE;
558 : 0 : opts->fastopen_cookie = &fastopen->cookie;
559 : 0 : remaining -= need;
560 : 0 : tp->syn_fastopen = 1;
561 : : }
562 : : }
563 : :
564 : 0 : return MAX_TCP_OPTION_SPACE - remaining;
565 : : }
566 : :
567 : : /* Set up TCP options for SYN-ACKs. */
568 : 0 : static unsigned int tcp_synack_options(struct sock *sk,
569 : : struct request_sock *req,
570 : : unsigned int mss, struct sk_buff *skb,
571 : : struct tcp_out_options *opts,
572 : : struct tcp_md5sig_key **md5,
573 : : struct tcp_fastopen_cookie *foc)
574 : : {
575 : : struct inet_request_sock *ireq = inet_rsk(req);
576 : : unsigned int remaining = MAX_TCP_OPTION_SPACE;
577 : :
578 : : #ifdef CONFIG_TCP_MD5SIG
579 : : *md5 = tcp_rsk(req)->af_specific->md5_lookup(sk, req);
580 : : if (*md5) {
581 : : opts->options |= OPTION_MD5;
582 : : remaining -= TCPOLEN_MD5SIG_ALIGNED;
583 : :
584 : : /* We can't fit any SACK blocks in a packet with MD5 + TS
585 : : * options. There was discussion about disabling SACK
586 : : * rather than TS in order to fit in better with old,
587 : : * buggy kernels, but that was deemed to be unnecessary.
588 : : */
589 : : ireq->tstamp_ok &= !ireq->sack_ok;
590 : : }
591 : : #else
592 : 28 : *md5 = NULL;
593 : : #endif
594 : :
595 : : /* We always send an MSS option. */
596 : 28 : opts->mss = mss;
597 : : remaining -= TCPOLEN_MSS_ALIGNED;
598 : :
599 [ + - ]: 28 : if (likely(ireq->wscale_ok)) {
600 : 28 : opts->ws = ireq->rcv_wscale;
601 : 28 : opts->options |= OPTION_WSCALE;
602 : : remaining -= TCPOLEN_WSCALE_ALIGNED;
603 : : }
604 [ + - ]: 28 : if (likely(ireq->tstamp_ok)) {
605 : 28 : opts->options |= OPTION_TS;
606 : 28 : opts->tsval = TCP_SKB_CB(skb)->when;
607 : 28 : opts->tsecr = req->ts_recent;
608 : 28 : remaining -= TCPOLEN_TSTAMP_ALIGNED;
609 : : }
610 [ + ]: 28 : if (likely(ireq->sack_ok)) {
611 : 28 : opts->options |= OPTION_SACK_ADVERTISE;
612 [ - + ]: 28 : if (unlikely(!ireq->tstamp_ok))
613 : 0 : remaining -= TCPOLEN_SACKPERM_ALIGNED;
614 : : }
615 [ # # ]: 0 : if (foc != NULL) {
616 : 0 : u32 need = TCPOLEN_EXP_FASTOPEN_BASE + foc->len;
617 : 0 : need = (need + 3) & ~3U; /* Align to 32 bits */
618 [ # # ]: 0 : if (remaining >= need) {
619 : 0 : opts->options |= OPTION_FAST_OPEN_COOKIE;
620 : 0 : opts->fastopen_cookie = foc;
621 : 0 : remaining -= need;
622 : : }
623 : : }
624 : :
625 : 0 : return MAX_TCP_OPTION_SPACE - remaining;
626 : : }
627 : :
628 : : /* Compute TCP options for ESTABLISHED sockets. This is not the
629 : : * final wire format yet.
630 : : */
631 : 0 : static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb,
632 : : struct tcp_out_options *opts,
633 : : struct tcp_md5sig_key **md5)
634 : : {
635 [ + + ]: 95769 : struct tcp_skb_cb *tcb = skb ? TCP_SKB_CB(skb) : NULL;
636 : : struct tcp_sock *tp = tcp_sk(sk);
637 : : unsigned int size = 0;
638 : : unsigned int eff_sacks;
639 : :
640 : 95769 : opts->options = 0;
641 : :
642 : : #ifdef CONFIG_TCP_MD5SIG
643 : : *md5 = tp->af_specific->md5_lookup(sk, sk);
644 : : if (unlikely(*md5)) {
645 : : opts->options |= OPTION_MD5;
646 : : size += TCPOLEN_MD5SIG_ALIGNED;
647 : : }
648 : : #else
649 : 95769 : *md5 = NULL;
650 : : #endif
651 : :
652 [ + - ]: 95769 : if (likely(tp->rx_opt.tstamp_ok)) {
653 : 95769 : opts->options |= OPTION_TS;
654 [ + + ]: 95769 : opts->tsval = tcb ? tcb->when + tp->tsoffset : 0;
655 : 95769 : opts->tsecr = tp->rx_opt.ts_recent;
656 : : size += TCPOLEN_TSTAMP_ALIGNED;
657 : : }
658 : :
659 : 0 : eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
660 [ # # ]: 95769 : if (unlikely(eff_sacks)) {
661 : : const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
662 : 3724 : opts->num_sack_blocks =
663 : 3724 : min_t(unsigned int, eff_sacks,
664 : : (remaining - TCPOLEN_SACK_BASE_ALIGNED) /
665 : : TCPOLEN_SACK_PERBLOCK);
666 : 3724 : size += TCPOLEN_SACK_BASE_ALIGNED +
667 : 3724 : opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
668 : : }
669 : :
670 : 0 : return size;
671 : : }
672 : :
673 : :
674 : : /* TCP SMALL QUEUES (TSQ)
675 : : *
676 : : * TSQ goal is to keep small amount of skbs per tcp flow in tx queues (qdisc+dev)
677 : : * to reduce RTT and bufferbloat.
678 : : * We do this using a special skb destructor (tcp_wfree).
679 : : *
680 : : * Its important tcp_wfree() can be replaced by sock_wfree() in the event skb
681 : : * needs to be reallocated in a driver.
682 : : * The invariant being skb->truesize substracted from sk->sk_wmem_alloc
683 : : *
684 : : * Since transmit from skb destructor is forbidden, we use a tasklet
685 : : * to process all sockets that eventually need to send more skbs.
686 : : * We use one tasklet per cpu, with its own queue of sockets.
687 : : */
688 : : struct tsq_tasklet {
689 : : struct tasklet_struct tasklet;
690 : : struct list_head head; /* queue of tcp sockets */
691 : : };
692 : : static DEFINE_PER_CPU(struct tsq_tasklet, tsq_tasklet);
693 : :
694 : 0 : static void tcp_tsq_handler(struct sock *sk)
695 : : {
696 [ # # ]: 0 : if ((1 << sk->sk_state) &
697 : : (TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_CLOSING |
698 : : TCPF_CLOSE_WAIT | TCPF_LAST_ACK))
699 : 0 : tcp_write_xmit(sk, tcp_current_mss(sk), 0, 0, GFP_ATOMIC);
700 : 0 : }
701 : : /*
702 : : * One tasklest per cpu tries to send more skbs.
703 : : * We run in tasklet context but need to disable irqs when
704 : : * transfering tsq->head because tcp_wfree() might
705 : : * interrupt us (non NAPI drivers)
706 : : */
707 : 0 : static void tcp_tasklet_func(unsigned long data)
708 : : {
709 : 0 : struct tsq_tasklet *tsq = (struct tsq_tasklet *)data;
710 : 0 : LIST_HEAD(list);
711 : : unsigned long flags;
712 : : struct list_head *q, *n;
713 : : struct tcp_sock *tp;
714 : : struct sock *sk;
715 : :
716 : : local_irq_save(flags);
717 : 0 : list_splice_init(&tsq->head, &list);
718 [ # # ]: 0 : local_irq_restore(flags);
719 : :
720 [ # # ]: 0 : list_for_each_safe(q, n, &list) {
721 : 0 : tp = list_entry(q, struct tcp_sock, tsq_node);
722 : : list_del(&tp->tsq_node);
723 : :
724 : : sk = (struct sock *)tp;
725 : : bh_lock_sock(sk);
726 : :
727 [ # # ]: 0 : if (!sock_owned_by_user(sk)) {
728 : 0 : tcp_tsq_handler(sk);
729 : : } else {
730 : : /* defer the work to tcp_release_cb() */
731 : 0 : set_bit(TCP_TSQ_DEFERRED, &tp->tsq_flags);
732 : : }
733 : : bh_unlock_sock(sk);
734 : :
735 : 0 : clear_bit(TSQ_QUEUED, &tp->tsq_flags);
736 : 0 : sk_free(sk);
737 : : }
738 : 0 : }
739 : :
740 : : #define TCP_DEFERRED_ALL ((1UL << TCP_TSQ_DEFERRED) | \
741 : : (1UL << TCP_WRITE_TIMER_DEFERRED) | \
742 : : (1UL << TCP_DELACK_TIMER_DEFERRED) | \
743 : : (1UL << TCP_MTU_REDUCED_DEFERRED))
744 : : /**
745 : : * tcp_release_cb - tcp release_sock() callback
746 : : * @sk: socket
747 : : *
748 : : * called from release_sock() to perform protocol dependent
749 : : * actions before socket release.
750 : : */
751 : 68146 : void tcp_release_cb(struct sock *sk)
752 : : {
753 : : struct tcp_sock *tp = tcp_sk(sk);
754 : : unsigned long flags, nflags;
755 : :
756 : : /* perform an atomic operation only if at least one flag is set */
757 : : do {
758 : 68146 : flags = tp->tsq_flags;
759 [ + + ]: 68146 : if (!(flags & TCP_DEFERRED_ALL))
760 : 68146 : return;
761 : 4 : nflags = flags & ~TCP_DEFERRED_ALL;
762 [ - + ]: 4 : } while (cmpxchg(&tp->tsq_flags, flags, nflags) != flags);
763 : :
764 [ - + ]: 4 : if (flags & (1UL << TCP_TSQ_DEFERRED))
765 : 0 : tcp_tsq_handler(sk);
766 : :
767 [ + + ]: 68150 : if (flags & (1UL << TCP_WRITE_TIMER_DEFERRED)) {
768 : 2 : tcp_write_timer_handler(sk);
769 : : __sock_put(sk);
770 : : }
771 [ + + ]: 4 : if (flags & (1UL << TCP_DELACK_TIMER_DEFERRED)) {
772 : 2 : tcp_delack_timer_handler(sk);
773 : : __sock_put(sk);
774 : : }
775 [ - + ]: 4 : if (flags & (1UL << TCP_MTU_REDUCED_DEFERRED)) {
776 : 0 : sk->sk_prot->mtu_reduced(sk);
777 : : __sock_put(sk);
778 : : }
779 : : }
780 : : EXPORT_SYMBOL(tcp_release_cb);
781 : :
782 : 0 : void __init tcp_tasklet_init(void)
783 : : {
784 : : int i;
785 : :
786 [ # # ]: 0 : for_each_possible_cpu(i) {
787 : 0 : struct tsq_tasklet *tsq = &per_cpu(tsq_tasklet, i);
788 : :
789 : 0 : INIT_LIST_HEAD(&tsq->head);
790 : 0 : tasklet_init(&tsq->tasklet,
791 : : tcp_tasklet_func,
792 : : (unsigned long)tsq);
793 : : }
794 : 0 : }
795 : :
796 : : /*
797 : : * Write buffer destructor automatically called from kfree_skb.
798 : : * We cant xmit new skbs from this context, as we might already
799 : : * hold qdisc lock.
800 : : */
801 : 0 : void tcp_wfree(struct sk_buff *skb)
802 : : {
803 : 54470 : struct sock *sk = skb->sk;
804 : : struct tcp_sock *tp = tcp_sk(sk);
805 : :
806 [ - + # # ]: 54470 : if (test_and_clear_bit(TSQ_THROTTLED, &tp->tsq_flags) &&
807 : 0 : !test_and_set_bit(TSQ_QUEUED, &tp->tsq_flags)) {
808 : : unsigned long flags;
809 : : struct tsq_tasklet *tsq;
810 : :
811 : : /* Keep a ref on socket.
812 : : * This last ref will be released in tcp_tasklet_func()
813 : : */
814 : 0 : atomic_sub(skb->truesize - 1, &sk->sk_wmem_alloc);
815 : :
816 : : /* queue this socket to tasklet queue */
817 : : local_irq_save(flags);
818 : 0 : tsq = &__get_cpu_var(tsq_tasklet);
819 : 0 : list_add(&tp->tsq_node, &tsq->head);
820 : 0 : tasklet_schedule(&tsq->tasklet);
821 [ # # ]: 0 : local_irq_restore(flags);
822 : : } else {
823 : 54469 : sock_wfree(skb);
824 : : }
825 : 54470 : }
826 : :
827 : : /* This routine actually transmits TCP packets queued in by
828 : : * tcp_do_sendmsg(). This is used by both the initial
829 : : * transmission and possible later retransmissions.
830 : : * All SKB's seen here are completely headerless. It is our
831 : : * job to build the TCP header, and pass the packet down to
832 : : * IP so it can do the same plus pass the packet off to the
833 : : * device.
834 : : *
835 : : * We are working here with either a clone of the original
836 : : * SKB, or a fresh unique copy made by the retransmit engine.
837 : : */
838 : 0 : static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
839 : : gfp_t gfp_mask)
840 : : {
841 : : const struct inet_connection_sock *icsk = inet_csk(sk);
842 : : struct inet_sock *inet;
843 : : struct tcp_sock *tp;
844 : : struct tcp_skb_cb *tcb;
845 : : struct tcp_out_options opts;
846 : : unsigned int tcp_options_size, tcp_header_size;
847 : : struct tcp_md5sig_key *md5;
848 : : struct tcphdr *th;
849 : : int err;
850 : :
851 [ + - ][ + + ]: 54470 : BUG_ON(!skb || !tcp_skb_pcount(skb));
852 : :
853 [ + + ]: 54469 : if (clone_it) {
854 : : const struct sk_buff *fclone = skb + 1;
855 : :
856 : : /* If congestion control is doing timestamping, we must
857 : : * take such a timestamp before we potentially clone/copy.
858 : : */
859 [ + + ]: 41682 : if (icsk->icsk_ca_ops->flags & TCP_CONG_RTT_STAMP)
860 : : __net_timestamp(skb);
861 : :
862 [ + + ][ - + ]: 41683 : if (unlikely(skb->fclone == SKB_FCLONE_ORIG &&
863 : : fclone->fclone == SKB_FCLONE_CLONE))
864 : 0 : NET_INC_STATS_BH(sock_net(sk),
865 : : LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
866 : :
867 [ - + ]: 41683 : if (unlikely(skb_cloned(skb)))
868 : : skb = pskb_copy(skb, gfp_mask);
869 : : else
870 : 41683 : skb = skb_clone(skb, gfp_mask);
871 [ + - ]: 41682 : if (unlikely(!skb))
872 : : return -ENOBUFS;
873 : : }
874 : :
875 : : inet = inet_sk(sk);
876 : : tp = tcp_sk(sk);
877 : : tcb = TCP_SKB_CB(skb);
878 : 54469 : memset(&opts, 0, sizeof(opts));
879 : :
880 [ + + ]: 54469 : if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
881 : 30 : tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
882 : : else
883 : 54439 : tcp_options_size = tcp_established_options(sk, skb, &opts,
884 : : &md5);
885 : 54470 : tcp_header_size = tcp_options_size + sizeof(struct tcphdr);
886 : :
887 [ + + ]: 54470 : if (tcp_packets_in_flight(tp) == 0)
888 : : tcp_ca_event(sk, CA_EVENT_TX_START);
889 : :
890 : : /* if no packet is in qdisc/device queue, then allow XPS to select
891 : : * another queue.
892 : : */
893 : 54470 : skb->ooo_okay = sk_wmem_alloc_get(sk) == 0;
894 : :
895 : 54470 : skb_push(skb, tcp_header_size);
896 : : skb_reset_transport_header(skb);
897 : :
898 : : skb_orphan(skb);
899 : 54469 : skb->sk = sk;
900 : 54469 : skb->destructor = tcp_wfree;
901 : 54469 : atomic_add(skb->truesize, &sk->sk_wmem_alloc);
902 : :
903 : : /* Build TCP header and checksum it. */
904 : : th = tcp_hdr(skb);
905 : 108938 : th->source = inet->inet_sport;
906 : 108938 : th->dest = inet->inet_dport;
907 [ + + ]: 108938 : th->seq = htonl(tcb->seq);
908 [ - + ]: 54468 : th->ack_seq = htonl(tp->rcv_nxt);
909 [ + ]: 54468 : *(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) |
910 : : tcb->tcp_flags);
911 : :
912 [ + + ]: 54468 : if (unlikely(tcb->tcp_flags & TCPHDR_SYN)) {
913 : : /* RFC1323: The window in SYN & SYN/ACK segments
914 : : * is never scaled.
915 : : */
916 : 30 : th->window = htons(min(tp->rcv_wnd, 65535U));
917 : : } else {
918 : 54438 : th->window = htons(tcp_select_window(sk));
919 : : }
920 : 54469 : th->check = 0;
921 : 54469 : th->urg_ptr = 0;
922 : :
923 : : /* The urg_mode check is necessary during a below snd_una win probe */
924 [ - + ][ # # ]: 54469 : if (unlikely(tcp_urg_mode(tp) && before(tcb->seq, tp->snd_up))) {
925 [ # # ]: 0 : if (before(tp->snd_up, tcb->seq + 0x10000)) {
926 [ # # ]: 0 : th->urg_ptr = htons(tp->snd_up - tcb->seq);
927 : 0 : th->urg = 1;
928 [ # # ]: 0 : } else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
929 : 0 : th->urg_ptr = htons(0xFFFF);
930 : 0 : th->urg = 1;
931 : : }
932 : : }
933 : :
934 : 54469 : tcp_options_write((__be32 *)(th + 1), tp, &opts);
935 [ + + ]: 54470 : if (likely((tcb->tcp_flags & TCPHDR_SYN) == 0))
936 : : TCP_ECN_send(sk, skb, tcp_header_size);
937 : :
938 : : #ifdef CONFIG_TCP_MD5SIG
939 : : /* Calculate the MD5 hash, as we have all we need now */
940 : : if (md5) {
941 : : sk_nocaps_add(sk, NETIF_F_GSO_MASK);
942 : : tp->af_specific->calc_md5_hash(opts.hash_location,
943 : : md5, sk, NULL, skb);
944 : : }
945 : : #endif
946 : :
947 : 54470 : icsk->icsk_af_ops->send_check(sk, skb);
948 : :
949 [ + + ]: 54470 : if (likely(tcb->tcp_flags & TCPHDR_ACK))
950 : 54439 : tcp_event_ack_sent(sk, tcp_skb_pcount(skb));
951 : :
952 [ + + ]: 54470 : if (skb->len != tcp_header_size)
953 : 41619 : tcp_event_data_sent(tp, sk);
954 : :
955 [ + + ][ + + ]: 54470 : if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
956 : 163329 : TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
957 : : tcp_skb_pcount(skb));
958 : :
959 : 54470 : err = icsk->icsk_af_ops->queue_xmit(skb, &inet->cork.fl);
960 [ - + ]: 54470 : if (likely(err <= 0))
961 : : return err;
962 : :
963 : 0 : tcp_enter_cwr(sk, 1);
964 : :
965 [ # # ]: 0 : return net_xmit_eval(err);
966 : : }
967 : :
968 : : /* This routine just queues the buffer for sending.
969 : : *
970 : : * NOTE: probe0 timer is not checked, do not forget tcp_push_pending_frames,
971 : : * otherwise socket can stall.
972 : : */
973 : 0 : static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb)
974 : : {
975 : : struct tcp_sock *tp = tcp_sk(sk);
976 : :
977 : : /* Advance write_seq and place onto the write_queue. */
978 : 33 : tp->write_seq = TCP_SKB_CB(skb)->end_seq;
979 : : skb_header_release(skb);
980 : : tcp_add_write_queue_tail(sk, skb);
981 : 33 : sk->sk_wmem_queued += skb->truesize;
982 : 33 : sk_mem_charge(sk, skb->truesize);
983 : 0 : }
984 : :
985 : : /* Initialize TSO segments for a packet. */
986 : 0 : static void tcp_set_skb_tso_segs(const struct sock *sk, struct sk_buff *skb,
987 : : unsigned int mss_now)
988 : : {
989 : : /* Make sure we own this skb before messing gso_size/gso_segs */
990 [ - + ][ # # ]: 41700 : WARN_ON_ONCE(skb_cloned(skb));
[ - ]
991 : :
992 [ - + ][ # # ]: 41699 : if (skb->len <= mss_now || skb->ip_summed == CHECKSUM_NONE) {
993 : : /* Avoid the costly divide in the normal
994 : : * non-TSO case.
995 : : */
996 : 41699 : skb_shinfo(skb)->gso_segs = 1;
997 : 41699 : skb_shinfo(skb)->gso_size = 0;
998 : 41699 : skb_shinfo(skb)->gso_type = 0;
999 : : } else {
1000 : 0 : skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss_now);
1001 : 0 : skb_shinfo(skb)->gso_size = mss_now;
1002 : 0 : skb_shinfo(skb)->gso_type = sk->sk_gso_type;
1003 : : }
1004 : 41699 : }
1005 : :
1006 : : /* When a modification to fackets out becomes necessary, we need to check
1007 : : * skb is counted to fackets_out or not.
1008 : : */
1009 : 0 : static void tcp_adjust_fackets_out(struct sock *sk, const struct sk_buff *skb,
1010 : : int decr)
1011 : : {
1012 : : struct tcp_sock *tp = tcp_sk(sk);
1013 : :
1014 [ # # ][ # # ]: 0 : if (!tp->sacked_out || tcp_is_reno(tp))
1015 : 0 : return;
1016 : :
1017 [ # # ]: 0 : if (after(tcp_highest_sack_seq(tp), TCP_SKB_CB(skb)->seq))
1018 : 0 : tp->fackets_out -= decr;
1019 : : }
1020 : :
1021 : : /* Pcount in the middle of the write queue got changed, we need to do various
1022 : : * tweaks to fix counters
1023 : : */
1024 : 0 : static void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr)
1025 : : {
1026 : : struct tcp_sock *tp = tcp_sk(sk);
1027 : :
1028 : 0 : tp->packets_out -= decr;
1029 : :
1030 [ # # ]: 0 : if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
1031 : 0 : tp->sacked_out -= decr;
1032 [ # # ]: 0 : if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)
1033 : 0 : tp->retrans_out -= decr;
1034 [ # # ]: 0 : if (TCP_SKB_CB(skb)->sacked & TCPCB_LOST)
1035 : 0 : tp->lost_out -= decr;
1036 : :
1037 : : /* Reno case is special. Sigh... */
1038 [ # # ][ # # ]: 0 : if (tcp_is_reno(tp) && decr > 0)
1039 : 0 : tp->sacked_out -= min_t(u32, tp->sacked_out, decr);
1040 : :
1041 : 0 : tcp_adjust_fackets_out(sk, skb, decr);
1042 : :
1043 [ # # ][ # # ]: 0 : if (tp->lost_skb_hint &&
1044 [ # # ]: 0 : before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(tp->lost_skb_hint)->seq) &&
1045 [ # # ]: 0 : (tcp_is_fack(tp) || (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)))
1046 : 0 : tp->lost_cnt_hint -= decr;
1047 : :
1048 [ # # ]: 0 : tcp_verify_left_out(tp);
1049 : 0 : }
1050 : :
1051 : : /* Function to create two new TCP segments. Shrinks the given segment
1052 : : * to the specified size and appends a new segment with the rest of the
1053 : : * packet to the list. This won't be called frequently, I hope.
1054 : : * Remember, these are still headerless SKBs at this point.
1055 : : */
1056 : 0 : int tcp_fragment(struct sock *sk, struct sk_buff *skb, u32 len,
1057 : : unsigned int mss_now)
1058 : : {
1059 : : struct tcp_sock *tp = tcp_sk(sk);
1060 : : struct sk_buff *buff;
1061 : : int nsize, old_factor;
1062 : : int nlen;
1063 : : u8 flags;
1064 : :
1065 [ # # ][ # # ]: 0 : if (WARN_ON(len > skb->len))
1066 : : return -EINVAL;
1067 : :
1068 : 0 : nsize = skb_headlen(skb) - len;
1069 [ # # ]: 0 : if (nsize < 0)
1070 : : nsize = 0;
1071 : :
1072 [ # # ]: 0 : if (skb_unclone(skb, GFP_ATOMIC))
1073 : : return -ENOMEM;
1074 : :
1075 : : /* Get a new skb... force flag on. */
1076 : 0 : buff = sk_stream_alloc_skb(sk, nsize, GFP_ATOMIC);
1077 [ # # ]: 0 : if (buff == NULL)
1078 : : return -ENOMEM; /* We'll just try again later. */
1079 : :
1080 : 0 : sk->sk_wmem_queued += buff->truesize;
1081 : 0 : sk_mem_charge(sk, buff->truesize);
1082 : 0 : nlen = skb->len - len - nsize;
1083 : 0 : buff->truesize += nlen;
1084 : 0 : skb->truesize -= nlen;
1085 : :
1086 : : /* Correct the sequence numbers. */
1087 : 0 : TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
1088 : 0 : TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
1089 : 0 : TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
1090 : :
1091 : : /* PSH and FIN should only be set in the second packet. */
1092 : 0 : flags = TCP_SKB_CB(skb)->tcp_flags;
1093 : 0 : TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
1094 : 0 : TCP_SKB_CB(buff)->tcp_flags = flags;
1095 : 0 : TCP_SKB_CB(buff)->sacked = TCP_SKB_CB(skb)->sacked;
1096 : :
1097 [ # # ][ # # ]: 0 : if (!skb_shinfo(skb)->nr_frags && skb->ip_summed != CHECKSUM_PARTIAL) {
1098 : : /* Copy and checksum data tail into the new buffer. */
1099 : 0 : buff->csum = csum_partial_copy_nocheck(skb->data + len,
1100 : 0 : skb_put(buff, nsize),
1101 : : nsize, 0);
1102 : :
1103 : 0 : skb_trim(skb, len);
1104 : :
1105 : 0 : skb->csum = csum_block_sub(skb->csum, buff->csum, len);
1106 : : } else {
1107 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
1108 : 0 : skb_split(skb, buff, len);
1109 : : }
1110 : :
1111 : 0 : buff->ip_summed = skb->ip_summed;
1112 : :
1113 : : /* Looks stupid, but our code really uses when of
1114 : : * skbs, which it never sent before. --ANK
1115 : : */
1116 : 0 : TCP_SKB_CB(buff)->when = TCP_SKB_CB(skb)->when;
1117 : 0 : buff->tstamp = skb->tstamp;
1118 : :
1119 : : old_factor = tcp_skb_pcount(skb);
1120 : :
1121 : : /* Fix up tso_factor for both original and new SKB. */
1122 : 0 : tcp_set_skb_tso_segs(sk, skb, mss_now);
1123 : 0 : tcp_set_skb_tso_segs(sk, buff, mss_now);
1124 : :
1125 : : /* If this packet has been sent out already, we must
1126 : : * adjust the various packet counters.
1127 : : */
1128 [ # # ]: 0 : if (!before(tp->snd_nxt, TCP_SKB_CB(buff)->end_seq)) {
1129 : 0 : int diff = old_factor - tcp_skb_pcount(skb) -
1130 : : tcp_skb_pcount(buff);
1131 : :
1132 [ # # ]: 0 : if (diff)
1133 : 0 : tcp_adjust_pcount(sk, skb, diff);
1134 : : }
1135 : :
1136 : : /* Link BUFF into the send queue. */
1137 : : skb_header_release(buff);
1138 : : tcp_insert_write_queue_after(skb, buff, sk);
1139 : :
1140 : 0 : return 0;
1141 : : }
1142 : :
1143 : : /* This is similar to __pskb_pull_head() (it will go to core/skbuff.c
1144 : : * eventually). The difference is that pulled data not copied, but
1145 : : * immediately discarded.
1146 : : */
1147 : 0 : static void __pskb_trim_head(struct sk_buff *skb, int len)
1148 : : {
1149 : : int i, k, eat;
1150 : :
1151 : 0 : eat = min_t(int, len, skb_headlen(skb));
1152 [ # # ]: 0 : if (eat) {
1153 : 0 : __skb_pull(skb, eat);
1154 : 0 : len -= eat;
1155 [ # # ]: 0 : if (!len)
1156 : 0 : return;
1157 : : }
1158 : : eat = len;
1159 : : k = 0;
1160 [ # # ]: 0 : for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1161 : 0 : int size = skb_frag_size(&skb_shinfo(skb)->frags[i]);
1162 : :
1163 [ # # ]: 0 : if (size <= eat) {
1164 : : skb_frag_unref(skb, i);
1165 : 0 : eat -= size;
1166 : : } else {
1167 : 0 : skb_shinfo(skb)->frags[k] = skb_shinfo(skb)->frags[i];
1168 [ # # ]: 0 : if (eat) {
1169 : 0 : skb_shinfo(skb)->frags[k].page_offset += eat;
1170 : 0 : skb_frag_size_sub(&skb_shinfo(skb)->frags[k], eat);
1171 : : eat = 0;
1172 : : }
1173 : 0 : k++;
1174 : : }
1175 : : }
1176 : 0 : skb_shinfo(skb)->nr_frags = k;
1177 : :
1178 : : skb_reset_tail_pointer(skb);
1179 : 0 : skb->data_len -= len;
1180 : 0 : skb->len = skb->data_len;
1181 : : }
1182 : :
1183 : : /* Remove acked data from a packet in the transmit queue. */
1184 : 0 : int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len)
1185 : : {
1186 [ # # ]: 0 : if (skb_unclone(skb, GFP_ATOMIC))
1187 : : return -ENOMEM;
1188 : :
1189 : 0 : __pskb_trim_head(skb, len);
1190 : :
1191 : 0 : TCP_SKB_CB(skb)->seq += len;
1192 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
1193 : :
1194 : 0 : skb->truesize -= len;
1195 : 0 : sk->sk_wmem_queued -= len;
1196 : : sk_mem_uncharge(sk, len);
1197 : : sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1198 : :
1199 : : /* Any change of skb->len requires recalculation of tso factor. */
1200 [ # # ]: 0 : if (tcp_skb_pcount(skb) > 1)
1201 : 0 : tcp_set_skb_tso_segs(sk, skb, tcp_skb_mss(skb));
1202 : :
1203 : : return 0;
1204 : : }
1205 : :
1206 : : /* Calculate MSS not accounting any TCP options. */
1207 : : static inline int __tcp_mtu_to_mss(struct sock *sk, int pmtu)
1208 : : {
1209 : : const struct tcp_sock *tp = tcp_sk(sk);
1210 : : const struct inet_connection_sock *icsk = inet_csk(sk);
1211 : : int mss_now;
1212 : :
1213 : : /* Calculate base mss without TCP options:
1214 : : It is MMS_S - sizeof(tcphdr) of rfc1122
1215 : : */
1216 : 286 : mss_now = pmtu - icsk->icsk_af_ops->net_header_len - sizeof(struct tcphdr);
1217 : :
1218 : : /* IPv6 adds a frag_hdr in case RTAX_FEATURE_ALLFRAG is set */
1219 [ # # ][ - + ]: 286 : if (icsk->icsk_af_ops->net_frag_header_len) {
1220 : : const struct dst_entry *dst = __sk_dst_get(sk);
1221 : :
1222 [ # # ][ # # ]: 0 : if (dst && dst_allfrag(dst))
[ # # ][ # # ]
1223 : 0 : mss_now -= icsk->icsk_af_ops->net_frag_header_len;
1224 : : }
1225 : :
1226 : : /* Clamp it (mss_clamp does not include tcp options) */
1227 [ # # ][ + + ]: 286 : if (mss_now > tp->rx_opt.mss_clamp)
1228 : : mss_now = tp->rx_opt.mss_clamp;
1229 : :
1230 : : /* Now subtract optional transport overhead */
1231 : 0 : mss_now -= icsk->icsk_ext_hdr_len;
1232 : :
1233 : : /* Then reserve room for full set of TCP options and 8 bytes of data */
1234 [ # # ][ # # ]: 286 : if (mss_now < 48)
1235 : : mss_now = 48;
1236 : : return mss_now;
1237 : : }
1238 : :
1239 : : /* Calculate MSS. Not accounting for SACKs here. */
1240 : 0 : int tcp_mtu_to_mss(struct sock *sk, int pmtu)
1241 : : {
1242 : : /* Subtract TCP options size, not including SACKs */
1243 : 0 : return __tcp_mtu_to_mss(sk, pmtu) -
1244 : 0 : (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr));
1245 : : }
1246 : :
1247 : : /* Inverse of above */
1248 : 0 : int tcp_mss_to_mtu(struct sock *sk, int mss)
1249 : : {
1250 : : const struct tcp_sock *tp = tcp_sk(sk);
1251 : : const struct inet_connection_sock *icsk = inet_csk(sk);
1252 : : int mtu;
1253 : :
1254 : 230 : mtu = mss +
1255 : 230 : tp->tcp_header_len +
1256 : 230 : icsk->icsk_ext_hdr_len +
1257 : 115 : icsk->icsk_af_ops->net_header_len;
1258 : :
1259 : : /* IPv6 adds a frag_hdr in case RTAX_FEATURE_ALLFRAG is set */
1260 [ - + ]: 115 : if (icsk->icsk_af_ops->net_frag_header_len) {
1261 : : const struct dst_entry *dst = __sk_dst_get(sk);
1262 : :
1263 [ # # ][ # # ]: 0 : if (dst && dst_allfrag(dst))
1264 : 0 : mtu += icsk->icsk_af_ops->net_frag_header_len;
1265 : : }
1266 : 0 : return mtu;
1267 : : }
1268 : :
1269 : : /* MTU probing init per socket */
1270 : 0 : void tcp_mtup_init(struct sock *sk)
1271 : : {
1272 : : struct tcp_sock *tp = tcp_sk(sk);
1273 : : struct inet_connection_sock *icsk = inet_csk(sk);
1274 : :
1275 : 115 : icsk->icsk_mtup.enabled = sysctl_tcp_mtu_probing > 1;
1276 : 230 : icsk->icsk_mtup.search_high = tp->rx_opt.mss_clamp + sizeof(struct tcphdr) +
1277 : 115 : icsk->icsk_af_ops->net_header_len;
1278 : 115 : icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, sysctl_tcp_base_mss);
1279 : 115 : icsk->icsk_mtup.probe_size = 0;
1280 : 115 : }
1281 : : EXPORT_SYMBOL(tcp_mtup_init);
1282 : :
1283 : : /* This function synchronize snd mss to current pmtu/exthdr set.
1284 : :
1285 : : tp->rx_opt.user_mss is mss set by user by TCP_MAXSEG. It does NOT counts
1286 : : for TCP options, but includes only bare TCP header.
1287 : :
1288 : : tp->rx_opt.mss_clamp is mss negotiated at connection setup.
1289 : : It is minimum of user_mss and mss received with SYN.
1290 : : It also does not include TCP options.
1291 : :
1292 : : inet_csk(sk)->icsk_pmtu_cookie is last pmtu, seen by this function.
1293 : :
1294 : : tp->mss_cache is current effective sending mss, including
1295 : : all tcp options except for SACKs. It is evaluated,
1296 : : taking into account current pmtu, but never exceeds
1297 : : tp->rx_opt.mss_clamp.
1298 : :
1299 : : NOTE1. rfc1122 clearly states that advertised MSS
1300 : : DOES NOT include either tcp or ip options.
1301 : :
1302 : : NOTE2. inet_csk(sk)->icsk_pmtu_cookie and tp->mss_cache
1303 : : are READ ONLY outside this function. --ANK (980731)
1304 : : */
1305 : 0 : unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu)
1306 : : {
1307 : : struct tcp_sock *tp = tcp_sk(sk);
1308 : : struct inet_connection_sock *icsk = inet_csk(sk);
1309 : : int mss_now;
1310 : :
1311 [ - + ]: 286 : if (icsk->icsk_mtup.search_high > pmtu)
1312 : 0 : icsk->icsk_mtup.search_high = pmtu;
1313 : :
1314 : 286 : mss_now = tcp_mtu_to_mss(sk, pmtu);
1315 : : mss_now = tcp_bound_to_half_wnd(tp, mss_now);
1316 : :
1317 : : /* And store cached results */
1318 : 286 : icsk->icsk_pmtu_cookie = pmtu;
1319 [ - + ]: 286 : if (icsk->icsk_mtup.enabled)
1320 : 0 : mss_now = min(mss_now, tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low));
1321 : 0 : tp->mss_cache = mss_now;
1322 : :
1323 : 0 : return mss_now;
1324 : : }
1325 : : EXPORT_SYMBOL(tcp_sync_mss);
1326 : :
1327 : : /* Compute the current effective MSS, taking SACKs and IP options,
1328 : : * and even PMTU discovery events into account.
1329 : : */
1330 : 0 : unsigned int tcp_current_mss(struct sock *sk)
1331 : : {
1332 : : const struct tcp_sock *tp = tcp_sk(sk);
1333 : : const struct dst_entry *dst = __sk_dst_get(sk);
1334 : : u32 mss_now;
1335 : : unsigned int header_len;
1336 : : struct tcp_out_options opts;
1337 : : struct tcp_md5sig_key *md5;
1338 : :
1339 : 41329 : mss_now = tp->mss_cache;
1340 : :
1341 [ + + ]: 41329 : if (dst) {
1342 : : u32 mtu = dst_mtu(dst);
1343 [ - + ]: 41327 : if (mtu != inet_csk(sk)->icsk_pmtu_cookie)
1344 : 0 : mss_now = tcp_sync_mss(sk, mtu);
1345 : : }
1346 : :
1347 : 41329 : header_len = tcp_established_options(sk, NULL, &opts, &md5) +
1348 : : sizeof(struct tcphdr);
1349 : : /* The mss_cache is sized based on tp->tcp_header_len, which assumes
1350 : : * some common options. If this is an odd packet (because we have SACK
1351 : : * blocks etc) then our calculated header_len will be different, and
1352 : : * we have to adjust mss_now correspondingly */
1353 [ - + ]: 41328 : if (header_len != tp->tcp_header_len) {
1354 : 0 : int delta = (int) header_len - tp->tcp_header_len;
1355 : 0 : mss_now -= delta;
1356 : : }
1357 : :
1358 : 41328 : return mss_now;
1359 : : }
1360 : :
1361 : : /* Congestion window validation. (RFC2861) */
1362 : 0 : static void tcp_cwnd_validate(struct sock *sk)
1363 : : {
1364 : : struct tcp_sock *tp = tcp_sk(sk);
1365 : :
1366 [ + + ]: 41623 : if (tp->packets_out >= tp->snd_cwnd) {
1367 : : /* Network is feed fully. */
1368 : 55 : tp->snd_cwnd_used = 0;
1369 : 55 : tp->snd_cwnd_stamp = tcp_time_stamp;
1370 : : } else {
1371 : : /* Network starves. */
1372 [ + + ]: 41568 : if (tp->packets_out > tp->snd_cwnd_used)
1373 : 7667 : tp->snd_cwnd_used = tp->packets_out;
1374 : :
1375 [ + ][ + + ]: 41568 : if (sysctl_tcp_slow_start_after_idle &&
1376 : 41569 : (s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto)
1377 : 62 : tcp_cwnd_application_limited(sk);
1378 : : }
1379 : 0 : }
1380 : :
1381 : : /* Returns the portion of skb which can be sent right away without
1382 : : * introducing MSS oddities to segment boundaries. In rare cases where
1383 : : * mss_now != mss_cache, we will request caller to create a small skb
1384 : : * per input skb which could be mostly avoided here (if desired).
1385 : : *
1386 : : * We explicitly want to create a request for splitting write queue tail
1387 : : * to a small skb for Nagle purposes while avoiding unnecessary modulos,
1388 : : * thus all the complexity (cwnd_len is always MSS multiple which we
1389 : : * return whenever allowed by the other factors). Basically we need the
1390 : : * modulo only when the receiver window alone is the limiting factor or
1391 : : * when we would be allowed to send the split-due-to-Nagle skb fully.
1392 : : */
1393 : 0 : static unsigned int tcp_mss_split_point(const struct sock *sk, const struct sk_buff *skb,
1394 : : unsigned int mss_now, unsigned int max_segs)
1395 : : {
1396 : : const struct tcp_sock *tp = tcp_sk(sk);
1397 : : u32 needed, window, max_len;
1398 : :
1399 : 0 : window = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
1400 : 0 : max_len = mss_now * max_segs;
1401 : :
1402 [ # # ][ # # ]: 0 : if (likely(max_len <= window && skb != tcp_write_queue_tail(sk)))
1403 : : return max_len;
1404 : :
1405 : 0 : needed = min(skb->len, window);
1406 : :
1407 [ # # ]: 0 : if (max_len <= needed)
1408 : : return max_len;
1409 : :
1410 : 0 : return needed - needed % mss_now;
1411 : : }
1412 : :
1413 : : /* Can at least one segment of SKB be sent right now, according to the
1414 : : * congestion window rules? If so, return how many segments are allowed.
1415 : : */
1416 : : static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp,
1417 : : const struct sk_buff *skb)
1418 : : {
1419 : : u32 in_flight, cwnd;
1420 : :
1421 : : /* Don't be strict about the congestion window for the final FIN. */
1422 [ + + ][ + ]: 83641 : if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) &&
[ # # ][ # # ]
1423 : : tcp_skb_pcount(skb) == 1)
1424 : : return 1;
1425 : :
1426 : : in_flight = tcp_packets_in_flight(tp);
1427 : 41790 : cwnd = tp->snd_cwnd;
1428 [ + + ][ # # ]: 41790 : if (in_flight < cwnd)
1429 : 41583 : return (cwnd - in_flight);
1430 : :
1431 : : return 0;
1432 : : }
1433 : :
1434 : : /* Initialize TSO state of a skb.
1435 : : * This must be invoked the first time we consider transmitting
1436 : : * SKB onto the wire.
1437 : : */
1438 : 0 : static int tcp_init_tso_segs(const struct sock *sk, struct sk_buff *skb,
1439 : : unsigned int mss_now)
1440 : : {
1441 : : int tso_segs = tcp_skb_pcount(skb);
1442 : :
1443 [ + + ][ - + ]: 41824 : if (!tso_segs || (tso_segs > 1 && tcp_skb_mss(skb) != mss_now)) {
[ # # ]
1444 : 41700 : tcp_set_skb_tso_segs(sk, skb, mss_now);
1445 : : tso_segs = tcp_skb_pcount(skb);
1446 : : }
1447 : 41824 : return tso_segs;
1448 : : }
1449 : :
1450 : : /* Minshall's variant of the Nagle send check. */
1451 : : static inline bool tcp_minshall_check(const struct tcp_sock *tp)
1452 : : {
1453 [ # # ][ # # ]: 0 : return after(tp->snd_sml, tp->snd_una) &&
[ # # ][ # # ]
1454 : 0 : !after(tp->snd_sml, tp->snd_nxt);
1455 : : }
1456 : :
1457 : : /* Return false, if packet can be sent now without violation Nagle's rules:
1458 : : * 1. It is full sized.
1459 : : * 2. Or it contains FIN. (already checked by caller)
1460 : : * 3. Or TCP_CORK is not set, and TCP_NODELAY is set.
1461 : : * 4. Or TCP_CORK is not set, and all sent packets are ACKed.
1462 : : * With Minshall's modification: all sent small packets are ACKed.
1463 : : */
1464 : : static inline bool tcp_nagle_check(const struct tcp_sock *tp,
1465 : : const struct sk_buff *skb,
1466 : : unsigned int mss_now, int nonagle)
1467 : : {
1468 [ + + ][ + ]: 41037 : return skb->len < mss_now &&
[ # # ][ # # ]
1469 [ + + ][ # # ]: 41036 : ((nonagle & TCP_NAGLE_CORK) ||
1470 [ - + ][ # # ]: 41038 : (!nonagle && tp->packets_out && tcp_minshall_check(tp)));
[ # # ][ # # ]
1471 : : }
1472 : :
1473 : : /* Return true if the Nagle test allows this packet to be
1474 : : * sent now.
1475 : : */
1476 : 0 : static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb,
1477 : : unsigned int cur_mss, int nonagle)
1478 : : {
1479 : : /* Nagle rule does not apply to frames, which sit in the middle of the
1480 : : * write_queue (they have no chances to get new data).
1481 : : *
1482 : : * This is implemented in the callers, where they modify the 'nonagle'
1483 : : * argument based upon the location of SKB in the send queue.
1484 : : */
1485 [ + + # # ]: 41626 : if (nonagle & TCP_NAGLE_PUSH)
1486 : : return true;
1487 : :
1488 : : /* Don't use the nagle rule for urgent data (or for the final FIN). */
1489 [ + - ][ + + ]: 41070 : if (tcp_urg_mode(tp) || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN))
[ # # ][ # # ]
1490 : : return true;
1491 : :
1492 [ - + ][ # # ]: 41037 : if (!tcp_nagle_check(tp, skb, cur_mss, nonagle))
1493 : : return true;
1494 : :
1495 : : return false;
1496 : : }
1497 : :
1498 : : /* Does at least the first segment of SKB fit into the send window? */
1499 : : static bool tcp_snd_wnd_test(const struct tcp_sock *tp,
1500 : : const struct sk_buff *skb,
1501 : : unsigned int cur_mss)
1502 : : {
1503 : 41626 : u32 end_seq = TCP_SKB_CB(skb)->end_seq;
1504 : :
1505 [ - + ][ # # ]: 41626 : if (skb->len > cur_mss)
1506 : 0 : end_seq = TCP_SKB_CB(skb)->seq + cur_mss;
1507 : :
1508 : : return !after(end_seq, tcp_wnd_end(tp));
1509 : : }
1510 : :
1511 : : /* This checks if the data bearing packet SKB (usually tcp_send_head(sk))
1512 : : * should be put on the wire right now. If so, it returns the number of
1513 : : * packets allowed by the congestion window.
1514 : : */
1515 : 0 : static unsigned int tcp_snd_test(const struct sock *sk, struct sk_buff *skb,
1516 : : unsigned int cur_mss, int nonagle)
1517 : : {
1518 : : const struct tcp_sock *tp = tcp_sk(sk);
1519 : : unsigned int cwnd_quota;
1520 : :
1521 : 0 : tcp_init_tso_segs(sk, skb, cur_mss);
1522 : :
1523 [ # # ]: 0 : if (!tcp_nagle_test(tp, skb, cur_mss, nonagle))
1524 : : return 0;
1525 : :
1526 : : cwnd_quota = tcp_cwnd_test(tp, skb);
1527 [ # # ][ # # ]: 0 : if (cwnd_quota && !tcp_snd_wnd_test(tp, skb, cur_mss))
1528 : : cwnd_quota = 0;
1529 : :
1530 : 0 : return cwnd_quota;
1531 : : }
1532 : :
1533 : : /* Test if sending is allowed right now. */
1534 : 0 : bool tcp_may_send_now(struct sock *sk)
1535 : : {
1536 : : const struct tcp_sock *tp = tcp_sk(sk);
1537 : : struct sk_buff *skb = tcp_send_head(sk);
1538 : :
1539 [ # # # # ]: 0 : return skb &&
1540 [ # # ]: 0 : tcp_snd_test(sk, skb, tcp_current_mss(sk),
1541 : : (tcp_skb_is_last(sk, skb) ?
1542 : 0 : tp->nonagle : TCP_NAGLE_PUSH));
1543 : : }
1544 : :
1545 : : /* Trim TSO SKB to LEN bytes, put the remaining data into a new packet
1546 : : * which is put after SKB on the list. It is very much like
1547 : : * tcp_fragment() except that it may make several kinds of assumptions
1548 : : * in order to speed up the splitting operation. In particular, we
1549 : : * know that all the data is in scatter-gather pages, and that the
1550 : : * packet has never been sent out before (and thus is not cloned).
1551 : : */
1552 : 0 : static int tso_fragment(struct sock *sk, struct sk_buff *skb, unsigned int len,
1553 : : unsigned int mss_now, gfp_t gfp)
1554 : : {
1555 : : struct sk_buff *buff;
1556 : 0 : int nlen = skb->len - len;
1557 : : u8 flags;
1558 : :
1559 : : /* All of a TSO frame must be composed of paged data. */
1560 [ # # ]: 0 : if (skb->len != skb->data_len)
1561 : 0 : return tcp_fragment(sk, skb, len, mss_now);
1562 : :
1563 : 0 : buff = sk_stream_alloc_skb(sk, 0, gfp);
1564 [ # # ]: 0 : if (unlikely(buff == NULL))
1565 : : return -ENOMEM;
1566 : :
1567 : 0 : sk->sk_wmem_queued += buff->truesize;
1568 : 0 : sk_mem_charge(sk, buff->truesize);
1569 : 0 : buff->truesize += nlen;
1570 : 0 : skb->truesize -= nlen;
1571 : :
1572 : : /* Correct the sequence numbers. */
1573 : 0 : TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
1574 : 0 : TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
1575 : 0 : TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
1576 : :
1577 : : /* PSH and FIN should only be set in the second packet. */
1578 : 0 : flags = TCP_SKB_CB(skb)->tcp_flags;
1579 : 0 : TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
1580 : 0 : TCP_SKB_CB(buff)->tcp_flags = flags;
1581 : :
1582 : : /* This packet was never sent out yet, so no SACK bits. */
1583 : 0 : TCP_SKB_CB(buff)->sacked = 0;
1584 : :
1585 : 0 : buff->ip_summed = skb->ip_summed = CHECKSUM_PARTIAL;
1586 : 0 : skb_split(skb, buff, len);
1587 : :
1588 : : /* Fix up tso_factor for both original and new SKB. */
1589 : 0 : tcp_set_skb_tso_segs(sk, skb, mss_now);
1590 : 0 : tcp_set_skb_tso_segs(sk, buff, mss_now);
1591 : :
1592 : : /* Link BUFF into the send queue. */
1593 : : skb_header_release(buff);
1594 : : tcp_insert_write_queue_after(skb, buff, sk);
1595 : :
1596 : 0 : return 0;
1597 : : }
1598 : :
1599 : : /* Try to defer sending, if possible, in order to minimize the amount
1600 : : * of TSO splitting we do. View it as a kind of TSO Nagle test.
1601 : : *
1602 : : * This algorithm is from John Heffner.
1603 : : */
1604 : 0 : static bool tcp_tso_should_defer(struct sock *sk, struct sk_buff *skb)
1605 : : {
1606 : : struct tcp_sock *tp = tcp_sk(sk);
1607 : : const struct inet_connection_sock *icsk = inet_csk(sk);
1608 : : u32 send_win, cong_win, limit, in_flight;
1609 : : int win_divisor;
1610 : :
1611 [ # # ]: 0 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
1612 : : goto send_now;
1613 : :
1614 [ # # ]: 0 : if (icsk->icsk_ca_state != TCP_CA_Open)
1615 : : goto send_now;
1616 : :
1617 : : /* Defer for less than two clock ticks. */
1618 [ # # ][ # # ]: 0 : if (tp->tso_deferred &&
1619 : 0 : (((u32)jiffies << 1) >> 1) - (tp->tso_deferred >> 1) > 1)
1620 : : goto send_now;
1621 : :
1622 : : in_flight = tcp_packets_in_flight(tp);
1623 : :
1624 [ # # ][ # # ]: 0 : BUG_ON(tcp_skb_pcount(skb) <= 1 || (tp->snd_cwnd <= in_flight));
1625 : :
1626 : 0 : send_win = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
1627 : :
1628 : : /* From in_flight test above, we know that cwnd > in_flight. */
1629 : 0 : cong_win = (tp->snd_cwnd - in_flight) * tp->mss_cache;
1630 : :
1631 : 0 : limit = min(send_win, cong_win);
1632 : :
1633 : : /* If a full-sized TSO skb can be sent, do it. */
1634 [ # # ]: 0 : if (limit >= min_t(unsigned int, sk->sk_gso_max_size,
1635 : : tp->xmit_size_goal_segs * tp->mss_cache))
1636 : : goto send_now;
1637 : :
1638 : : /* Middle in queue won't get any more data, full sendable already? */
1639 [ # # ][ # # ]: 0 : if ((skb != tcp_write_queue_tail(sk)) && (limit >= skb->len))
1640 : : goto send_now;
1641 : :
1642 : 0 : win_divisor = ACCESS_ONCE(sysctl_tcp_tso_win_divisor);
1643 [ # # ]: 0 : if (win_divisor) {
1644 : 0 : u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache);
1645 : :
1646 : : /* If at least some fraction of a window is available,
1647 : : * just use it.
1648 : : */
1649 : 0 : chunk /= win_divisor;
1650 [ # # ]: 0 : if (limit >= chunk)
1651 : : goto send_now;
1652 : : } else {
1653 : : /* Different approach, try not to defer past a single
1654 : : * ACK. Receiver should ACK every other full sized
1655 : : * frame, so if we have space for more than 3 frames
1656 : : * then send now.
1657 : : */
1658 [ # # ]: 0 : if (limit > tcp_max_tso_deferred_mss(tp) * tp->mss_cache)
1659 : : goto send_now;
1660 : : }
1661 : :
1662 : : /* Ok, it looks like it is advisable to defer.
1663 : : * Do not rearm the timer if already set to not break TCP ACK clocking.
1664 : : */
1665 [ # # ]: 0 : if (!tp->tso_deferred)
1666 : 0 : tp->tso_deferred = 1 | (jiffies << 1);
1667 : :
1668 : : return true;
1669 : :
1670 : : send_now:
1671 : 0 : tp->tso_deferred = 0;
1672 : 0 : return false;
1673 : : }
1674 : :
1675 : : /* Create a new MTU probe if we are ready.
1676 : : * MTU probe is regularly attempting to increase the path MTU by
1677 : : * deliberately sending larger packets. This discovers routing
1678 : : * changes resulting in larger path MTUs.
1679 : : *
1680 : : * Returns 0 if we should wait to probe (no cwnd available),
1681 : : * 1 if a probe was sent,
1682 : : * -1 otherwise
1683 : : */
1684 : 0 : static int tcp_mtu_probe(struct sock *sk)
1685 : : {
1686 : : struct tcp_sock *tp = tcp_sk(sk);
1687 : : struct inet_connection_sock *icsk = inet_csk(sk);
1688 : 0 : struct sk_buff *skb, *nskb, *next;
1689 : : int len;
1690 : : int probe_size;
1691 : : int size_needed;
1692 : : int copy;
1693 : : int mss_now;
1694 : :
1695 : : /* Not currently probing/verifying,
1696 : : * not in recovery,
1697 : : * have enough cwnd, and
1698 : : * not SACKing (the variable headers throw things off) */
1699 [ - + ][ # # ]: 41257 : if (!icsk->icsk_mtup.enabled ||
1700 [ # # ]: 0 : icsk->icsk_mtup.probe_size ||
1701 [ # # ]: 0 : inet_csk(sk)->icsk_ca_state != TCP_CA_Open ||
1702 : 0 : tp->snd_cwnd < 11 ||
1703 [ # # ]: 0 : tp->rx_opt.num_sacks || tp->rx_opt.dsack)
1704 : : return -1;
1705 : :
1706 : : /* Very simple search strategy: just double the MSS. */
1707 : 0 : mss_now = tcp_current_mss(sk);
1708 : 0 : probe_size = 2 * tp->mss_cache;
1709 : 0 : size_needed = probe_size + (tp->reordering + 1) * tp->mss_cache;
1710 [ # # ]: 0 : if (probe_size > tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_high)) {
1711 : : /* TODO: set timer for probe_converge_event */
1712 : : return -1;
1713 : : }
1714 : :
1715 : : /* Have enough data in the send queue to probe? */
1716 [ # # ]: 0 : if (tp->write_seq - tp->snd_nxt < size_needed)
1717 : : return -1;
1718 : :
1719 [ # # ]: 0 : if (tp->snd_wnd < size_needed)
1720 : : return -1;
1721 [ # # ]: 0 : if (after(tp->snd_nxt + size_needed, tcp_wnd_end(tp)))
1722 : : return 0;
1723 : :
1724 : : /* Do we need to wait to drain cwnd? With none in flight, don't stall */
1725 [ # # ]: 0 : if (tcp_packets_in_flight(tp) + 2 > tp->snd_cwnd) {
1726 [ # # ]: 0 : if (!tcp_packets_in_flight(tp))
1727 : : return -1;
1728 : : else
1729 : 0 : return 0;
1730 : : }
1731 : :
1732 : : /* We're allowed to probe. Build it now. */
1733 [ # # ]: 0 : if ((nskb = sk_stream_alloc_skb(sk, probe_size, GFP_ATOMIC)) == NULL)
1734 : : return -1;
1735 : 0 : sk->sk_wmem_queued += nskb->truesize;
1736 : 0 : sk_mem_charge(sk, nskb->truesize);
1737 : :
1738 : : skb = tcp_send_head(sk);
1739 : :
1740 : 0 : TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(skb)->seq;
1741 : 0 : TCP_SKB_CB(nskb)->end_seq = TCP_SKB_CB(skb)->seq + probe_size;
1742 : 0 : TCP_SKB_CB(nskb)->tcp_flags = TCPHDR_ACK;
1743 : 0 : TCP_SKB_CB(nskb)->sacked = 0;
1744 : 0 : nskb->csum = 0;
1745 : 0 : nskb->ip_summed = skb->ip_summed;
1746 : :
1747 : : tcp_insert_write_queue_before(nskb, skb, sk);
1748 : :
1749 : : len = 0;
1750 [ # # ]: 0 : tcp_for_write_queue_from_safe(skb, next, sk) {
1751 : 0 : copy = min_t(int, skb->len, probe_size - len);
1752 [ # # ]: 0 : if (nskb->ip_summed)
1753 : 0 : skb_copy_bits(skb, 0, skb_put(nskb, copy), copy);
1754 : : else
1755 : 0 : nskb->csum = skb_copy_and_csum_bits(skb, 0,
1756 : 0 : skb_put(nskb, copy),
1757 : : copy, nskb->csum);
1758 : :
1759 [ # # ]: 0 : if (skb->len <= copy) {
1760 : : /* We've eaten all the data from this skb.
1761 : : * Throw it away. */
1762 : 0 : TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1763 : : tcp_unlink_write_queue(skb, sk);
1764 : : sk_wmem_free_skb(sk, skb);
1765 : : } else {
1766 : 0 : TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags &
1767 : : ~(TCPHDR_FIN|TCPHDR_PSH);
1768 [ # # ]: 0 : if (!skb_shinfo(skb)->nr_frags) {
1769 : 0 : skb_pull(skb, copy);
1770 [ # # ]: 0 : if (skb->ip_summed != CHECKSUM_PARTIAL)
1771 : 0 : skb->csum = csum_partial(skb->data,
1772 : 0 : skb->len, 0);
1773 : : } else {
1774 : 0 : __pskb_trim_head(skb, copy);
1775 : 0 : tcp_set_skb_tso_segs(sk, skb, mss_now);
1776 : : }
1777 : 0 : TCP_SKB_CB(skb)->seq += copy;
1778 : : }
1779 : :
1780 : 0 : len += copy;
1781 : :
1782 [ # # ]: 0 : if (len >= probe_size)
1783 : : break;
1784 : : }
1785 : 0 : tcp_init_tso_segs(sk, nskb, nskb->len);
1786 : :
1787 : : /* We're ready to send. If this fails, the probe will
1788 : : * be resegmented into mss-sized pieces by tcp_write_xmit(). */
1789 : 0 : TCP_SKB_CB(nskb)->when = tcp_time_stamp;
1790 [ # # ]: 0 : if (!tcp_transmit_skb(sk, nskb, 1, GFP_ATOMIC)) {
1791 : : /* Decrement cwnd here because we are sending
1792 : : * effectively two packets. */
1793 : 0 : tp->snd_cwnd--;
1794 : 0 : tcp_event_new_data_sent(sk, nskb);
1795 : :
1796 : 0 : icsk->icsk_mtup.probe_size = tcp_mss_to_mtu(sk, nskb->len);
1797 : 0 : tp->mtu_probe.probe_seq_start = TCP_SKB_CB(nskb)->seq;
1798 : 0 : tp->mtu_probe.probe_seq_end = TCP_SKB_CB(nskb)->end_seq;
1799 : :
1800 : 0 : return 1;
1801 : : }
1802 : :
1803 : : return -1;
1804 : : }
1805 : :
1806 : : /* This routine writes packets to the network. It advances the
1807 : : * send_head. This happens as incoming acks open up the remote
1808 : : * window for us.
1809 : : *
1810 : : * LARGESEND note: !tcp_urg_mode is overkill, only frames between
1811 : : * snd_up-64k-mss .. snd_up cannot be large. However, taking into
1812 : : * account rare use of URG, this is not a big flaw.
1813 : : *
1814 : : * Send at most one packet when push_one > 0. Temporarily ignore
1815 : : * cwnd limit to force at most one packet out when push_one == 2.
1816 : :
1817 : : * Returns true, if no segments are in flight and we have queued segments,
1818 : : * but cannot send anything now because of SWS or another problem.
1819 : : */
1820 : 0 : static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
1821 : : int push_one, gfp_t gfp)
1822 : : {
1823 : : struct tcp_sock *tp = tcp_sk(sk);
1824 : : struct sk_buff *skb;
1825 : : unsigned int tso_segs, sent_pkts;
1826 : : int cwnd_quota;
1827 : : int result;
1828 : :
1829 : : sent_pkts = 0;
1830 : :
1831 [ + + ]: 41817 : if (!push_one) {
1832 : : /* Do MTU probing. */
1833 : 41256 : result = tcp_mtu_probe(sk);
1834 [ + - ]: 41256 : if (!result) {
1835 : : return false;
1836 [ - + ]: 41256 : } else if (result > 0) {
1837 : : sent_pkts = 1;
1838 : : }
1839 : : }
1840 : :
1841 [ + + ]: 82890 : while ((skb = tcp_send_head(sk))) {
1842 : : unsigned int limit;
1843 : :
1844 : 41824 : tso_segs = tcp_init_tso_segs(sk, skb, mss_now);
1845 [ - + ]: 41824 : BUG_ON(!tso_segs);
1846 : :
1847 [ - + ][ # # ]: 41824 : if (unlikely(tp->repair) && tp->repair_queue == TCP_SEND_QUEUE)
1848 : : goto repair; /* Skip network transmission */
1849 : :
1850 : 41824 : cwnd_quota = tcp_cwnd_test(tp, skb);
1851 [ + + ]: 41824 : if (!cwnd_quota) {
1852 [ + + ]: 207 : if (push_one == 2)
1853 : : /* Force out a loss probe pkt. */
1854 : : cwnd_quota = 1;
1855 : : else
1856 : : break;
1857 : : }
1858 : :
1859 [ + - ]: 41626 : if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now)))
1860 : : break;
1861 : :
1862 [ + - ]: 41626 : if (tso_segs == 1) {
1863 [ + + ][ + - ]: 83252 : if (unlikely(!tcp_nagle_test(tp, skb, mss_now,
1864 : : (tcp_skb_is_last(sk, skb) ?
1865 : : nonagle : TCP_NAGLE_PUSH))))
1866 : : break;
1867 : : } else {
1868 [ # # ][ # # ]: 0 : if (!push_one && tcp_tso_should_defer(sk, skb))
1869 : : break;
1870 : : }
1871 : :
1872 : : /* TCP Small Queues :
1873 : : * Control number of packets in qdisc/devices to two packets / or ~1 ms.
1874 : : * This allows for :
1875 : : * - better RTT estimation and ACK scheduling
1876 : : * - faster recovery
1877 : : * - high rates
1878 : : * Alas, some drivers / subsystems require a fair amount
1879 : : * of queued bytes to ensure line rate.
1880 : : * One example is wifi aggregation (802.11 AMPDU)
1881 : : */
1882 : 41626 : limit = max_t(unsigned int, sysctl_tcp_limit_output_bytes,
1883 : : sk->sk_pacing_rate >> 10);
1884 : :
1885 [ - + ]: 41626 : if (atomic_read(&sk->sk_wmem_alloc) > limit) {
1886 : 0 : set_bit(TSQ_THROTTLED, &tp->tsq_flags);
1887 : 0 : break;
1888 : : }
1889 : :
1890 : : limit = mss_now;
1891 [ - + ][ # # ]: 41626 : if (tso_segs > 1 && !tcp_urg_mode(tp))
1892 : 0 : limit = tcp_mss_split_point(sk, skb, mss_now,
1893 : 0 : min_t(unsigned int,
1894 : : cwnd_quota,
1895 : : sk->sk_gso_max_segs));
1896 : :
1897 [ - + # # ]: 41626 : if (skb->len > limit &&
1898 : 0 : unlikely(tso_fragment(sk, skb, limit, mss_now, gfp)))
1899 : : break;
1900 : :
1901 : 41626 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
1902 : :
1903 [ + - ]: 41626 : if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
1904 : : break;
1905 : :
1906 : : repair:
1907 : : /* Advance the send_head. This one is sent out.
1908 : : * This call will increment packets_out.
1909 : : */
1910 : 0 : tcp_event_new_data_sent(sk, skb);
1911 : :
1912 : : tcp_minshall_update(tp, mss_now, skb);
1913 : 41626 : sent_pkts += tcp_skb_pcount(skb);
1914 : :
1915 [ + + ]: 83443 : if (push_one)
1916 : : break;
1917 : : }
1918 : :
1919 [ + + ]: 41817 : if (likely(sent_pkts)) {
1920 [ - + ]: 41624 : if (tcp_in_cwnd_reduction(sk))
1921 : 0 : tp->prr_out += sent_pkts;
1922 : :
1923 : : /* Send one loss probe per tail loss episode. */
1924 [ + + ]: 41624 : if (push_one != 2)
1925 : 41615 : tcp_schedule_loss_probe(sk);
1926 : 41623 : tcp_cwnd_validate(sk);
1927 : 41624 : return false;
1928 : : }
1929 [ + - ][ - + ]: 193 : return (push_one == 2) || (!tp->packets_out && tcp_send_head(sk));
[ # # ]
1930 : : }
1931 : :
1932 : 0 : bool tcp_schedule_loss_probe(struct sock *sk)
1933 : : {
1934 : : struct inet_connection_sock *icsk = inet_csk(sk);
1935 : : struct tcp_sock *tp = tcp_sk(sk);
1936 : : u32 timeout, tlp_time_stamp, rto_time_stamp;
1937 : 59975 : u32 rtt = tp->srtt >> 3;
1938 : :
1939 [ - + ][ + - ]: 59975 : if (WARN_ON(icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS))
1940 : : return false;
1941 : : /* No consecutive loss probes. */
1942 [ - + ][ - + ]: 59975 : if (WARN_ON(icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)) {
1943 : 0 : tcp_rearm_rto(sk);
1944 : 0 : return false;
1945 : : }
1946 : : /* Don't do any loss probe on a Fast Open connection before 3WHS
1947 : : * finishes.
1948 : : */
1949 [ + - ]: 59975 : if (sk->sk_state == TCP_SYN_RECV)
1950 : : return false;
1951 : :
1952 : : /* TLP is only scheduled when next timer event is RTO. */
1953 [ + - ]: 59975 : if (icsk->icsk_pending != ICSK_TIME_RETRANS)
1954 : : return false;
1955 : :
1956 : : /* Schedule a loss probe in 2*RTT for SACK capable connections
1957 : : * in Open state, that are either limited by cwnd or application.
1958 : : */
1959 [ + - ][ + - ]: 59975 : if (sysctl_tcp_early_retrans < 3 || !rtt || !tp->packets_out ||
[ + + ][ + - ]
1960 [ + - ]: 59974 : !tcp_is_sack(tp) || inet_csk(sk)->icsk_ca_state != TCP_CA_Open)
1961 : : return false;
1962 : :
1963 [ + + ][ + + ]: 59974 : if ((tp->snd_cwnd > tcp_packets_in_flight(tp)) &&
1964 : : tcp_send_head(sk))
1965 : : return false;
1966 : :
1967 : : /* Probe timeout is at least 1.5*rtt + TCP_DELACK_MAX to account
1968 : : * for delayed ack when there's one outstanding packet.
1969 : : */
1970 : 59948 : timeout = rtt << 1;
1971 [ + + ]: 59948 : if (tp->packets_out == 1)
1972 : 30978 : timeout = max_t(u32, timeout,
1973 : : (rtt + (rtt >> 1) + TCP_DELACK_MAX));
1974 : 59948 : timeout = max_t(u32, timeout, msecs_to_jiffies(10));
1975 : :
1976 : : /* If RTO is shorter, just schedule TLP in its place. */
1977 : 59948 : tlp_time_stamp = tcp_time_stamp + timeout;
1978 : 59948 : rto_time_stamp = (u32)inet_csk(sk)->icsk_timeout;
1979 [ + + ]: 59948 : if ((s32)(tlp_time_stamp - rto_time_stamp) > 0) {
1980 : 586 : s32 delta = rto_time_stamp - tcp_time_stamp;
1981 [ + - ]: 586 : if (delta > 0)
1982 : : timeout = delta;
1983 : : }
1984 : :
1985 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_LOSS_PROBE, timeout,
1986 : : TCP_RTO_MAX);
1987 : 59948 : return true;
1988 : : }
1989 : :
1990 : : /* When probe timeout (PTO) fires, send a new segment if one exists, else
1991 : : * retransmit the last segment.
1992 : : */
1993 : 0 : void tcp_send_loss_probe(struct sock *sk)
1994 : : {
1995 : : struct tcp_sock *tp = tcp_sk(sk);
1996 : : struct sk_buff *skb;
1997 : : int pcount;
1998 : 44 : int mss = tcp_current_mss(sk);
1999 : : int err = -1;
2000 : :
2001 [ + + ]: 44 : if (tcp_send_head(sk) != NULL) {
2002 : 9 : err = tcp_write_xmit(sk, mss, TCP_NAGLE_OFF, 2, GFP_ATOMIC);
2003 : 9 : goto rearm_timer;
2004 : : }
2005 : :
2006 : : /* At most one outstanding TLP retransmission. */
2007 [ + + ]: 35 : if (tp->tlp_high_seq)
2008 : : goto rearm_timer;
2009 : :
2010 : : /* Retransmit last segment. */
2011 : : skb = tcp_write_queue_tail(sk);
2012 [ - + ][ + - ]: 27 : if (WARN_ON(!skb))
2013 : : goto rearm_timer;
2014 : :
2015 : : pcount = tcp_skb_pcount(skb);
2016 [ - + ][ + - ]: 27 : if (WARN_ON(!pcount))
2017 : : goto rearm_timer;
2018 : :
2019 [ - + ][ # # ]: 27 : if ((pcount > 1) && (skb->len > (pcount - 1) * mss)) {
2020 [ # # ]: 0 : if (unlikely(tcp_fragment(sk, skb, (pcount - 1) * mss, mss)))
2021 : : goto rearm_timer;
2022 : : skb = tcp_write_queue_tail(sk);
2023 : : }
2024 : :
2025 [ + - ][ + - ]: 27 : if (WARN_ON(!skb || !tcp_skb_pcount(skb)))
[ - + ][ + - ]
2026 : : goto rearm_timer;
2027 : :
2028 : : /* Probe with zero data doesn't trigger fast recovery. */
2029 [ + - ]: 27 : if (skb->len > 0)
2030 : 27 : err = __tcp_retransmit_skb(sk, skb);
2031 : :
2032 : : /* Record snd_nxt for loss detection. */
2033 [ + - ]: 27 : if (likely(!err))
2034 : 27 : tp->tlp_high_seq = tp->snd_nxt;
2035 : :
2036 : : rearm_timer:
2037 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2038 : 44 : inet_csk(sk)->icsk_rto,
2039 : : TCP_RTO_MAX);
2040 : :
2041 [ + + ]: 44 : if (likely(!err))
2042 : 36 : NET_INC_STATS_BH(sock_net(sk),
2043 : : LINUX_MIB_TCPLOSSPROBES);
2044 : 44 : return;
2045 : : }
2046 : :
2047 : : /* Push out any pending frames which were held back due to
2048 : : * TCP_CORK or attempt at coalescing tiny packets.
2049 : : * The socket must be locked by the caller.
2050 : : */
2051 : 0 : void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
2052 : : int nonagle)
2053 : : {
2054 : : /* If we are closed, the bytes will have to remain here.
2055 : : * In time closedown will finish, we empty the write queue and
2056 : : * all will be happy.
2057 : : */
2058 [ + + ]: 41256 : if (unlikely(sk->sk_state == TCP_CLOSE))
2059 : 41257 : return;
2060 : :
2061 [ - + ]: 41255 : if (tcp_write_xmit(sk, cur_mss, nonagle, 0,
2062 : : sk_gfp_atomic(sk, GFP_ATOMIC)))
2063 : : tcp_check_probe_timer(sk);
2064 : : }
2065 : :
2066 : : /* Send _single_ skb sitting at the send head. This function requires
2067 : : * true push pending frames to setup probe timer etc.
2068 : : */
2069 : 0 : void tcp_push_one(struct sock *sk, unsigned int mss_now)
2070 : : {
2071 : : struct sk_buff *skb = tcp_send_head(sk);
2072 : :
2073 [ + - ][ - + ]: 551 : BUG_ON(!skb || skb->len < mss_now);
2074 : :
2075 : 551 : tcp_write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, sk->sk_allocation);
2076 : 551 : }
2077 : :
2078 : : /* This function returns the amount that we can raise the
2079 : : * usable window based on the following constraints
2080 : : *
2081 : : * 1. The window can never be shrunk once it is offered (RFC 793)
2082 : : * 2. We limit memory per socket
2083 : : *
2084 : : * RFC 1122:
2085 : : * "the suggested [SWS] avoidance algorithm for the receiver is to keep
2086 : : * RECV.NEXT + RCV.WIN fixed until:
2087 : : * RCV.BUFF - RCV.USER - RCV.WINDOW >= min(1/2 RCV.BUFF, MSS)"
2088 : : *
2089 : : * i.e. don't raise the right edge of the window until you can raise
2090 : : * it at least MSS bytes.
2091 : : *
2092 : : * Unfortunately, the recommended algorithm breaks header prediction,
2093 : : * since header prediction assumes th->window stays fixed.
2094 : : *
2095 : : * Strictly speaking, keeping th->window fixed violates the receiver
2096 : : * side SWS prevention criteria. The problem is that under this rule
2097 : : * a stream of single byte packets will cause the right side of the
2098 : : * window to always advance by a single byte.
2099 : : *
2100 : : * Of course, if the sender implements sender side SWS prevention
2101 : : * then this will not be a problem.
2102 : : *
2103 : : * BSD seems to make the following compromise:
2104 : : *
2105 : : * If the free space is less than the 1/4 of the maximum
2106 : : * space available and the free space is less than 1/2 mss,
2107 : : * then set the window to 0.
2108 : : * [ Actually, bsd uses MSS and 1/4 of maximal _window_ ]
2109 : : * Otherwise, just prevent the window from shrinking
2110 : : * and from being larger than the largest representable value.
2111 : : *
2112 : : * This prevents incremental opening of the window in the regime
2113 : : * where TCP is limited by the speed of the reader side taking
2114 : : * data out of the TCP receive queue. It does nothing about
2115 : : * those cases where the window is constrained on the sender side
2116 : : * because the pipeline is full.
2117 : : *
2118 : : * BSD also seems to "accidentally" limit itself to windows that are a
2119 : : * multiple of MSS, at least until the free space gets quite small.
2120 : : * This would appear to be a side effect of the mbuf implementation.
2121 : : * Combining these two algorithms results in the observed behavior
2122 : : * of having a fixed window size at almost all times.
2123 : : *
2124 : : * Below we obtain similar behavior by forcing the offered window to
2125 : : * a multiple of the mss when it is feasible to do so.
2126 : : *
2127 : : * Note, we don't "adjust" for TIMESTAMP or SACK option bytes.
2128 : : * Regular options like TIMESTAMP are taken into account.
2129 : : */
2130 : 0 : u32 __tcp_select_window(struct sock *sk)
2131 : : {
2132 : : struct inet_connection_sock *icsk = inet_csk(sk);
2133 : : struct tcp_sock *tp = tcp_sk(sk);
2134 : : /* MSS for the peer's data. Previous versions used mss_clamp
2135 : : * here. I don't know if the value based on our guesses
2136 : : * of peer's MSS is better for the performance. It's more correct
2137 : : * but may be worse for the performance because of rcv_mss
2138 : : * fluctuations. --SAW 1998/11/1
2139 : : */
2140 : 82353 : int mss = icsk->icsk_ack.rcv_mss;
2141 : : int free_space = tcp_space(sk);
2142 : 164706 : int full_space = min_t(int, tp->window_clamp, tcp_full_space(sk));
2143 : : int window;
2144 : :
2145 [ - + ]: 82353 : if (mss > full_space)
2146 : : mss = full_space;
2147 : :
2148 [ - + ]: 82353 : if (free_space < (full_space >> 1)) {
2149 : 0 : icsk->icsk_ack.quick = 0;
2150 : :
2151 [ # # ]: 0 : if (sk_under_memory_pressure(sk))
2152 : 0 : tp->rcv_ssthresh = min(tp->rcv_ssthresh,
2153 : : 4U * tp->advmss);
2154 : :
2155 [ # # ]: 0 : if (free_space < mss)
2156 : : return 0;
2157 : : }
2158 : :
2159 [ + + ]: 164713 : if (free_space > tp->rcv_ssthresh)
2160 : 66141 : free_space = tp->rcv_ssthresh;
2161 : :
2162 : : /* Don't do rounding if we are using window scaling, since the
2163 : : * scaled window will not line up with the MSS boundary anyway.
2164 : : */
2165 : 82360 : window = tp->rcv_wnd;
2166 [ + - ]: 82360 : if (tp->rx_opt.rcv_wscale) {
2167 : : window = free_space;
2168 : :
2169 : : /* Advertise enough space so that it won't get scaled away.
2170 : : * Import case: prevent zero window announcement if
2171 : : * 1<<rcv_wscale > mss.
2172 : : */
2173 [ + + ]: 82360 : if (((window >> tp->rx_opt.rcv_wscale) << tp->rx_opt.rcv_wscale) != window)
2174 : 68014 : window = (((window >> tp->rx_opt.rcv_wscale) + 1)
2175 : : << tp->rx_opt.rcv_wscale);
2176 : : } else {
2177 : : /* Get the largest window that is a nice multiple of mss.
2178 : : * Window clamp already applied above.
2179 : : * If our current window offering is within 1 mss of the
2180 : : * free space we just keep it. This prevents the divide
2181 : : * and multiply from happening most of the time.
2182 : : * We also don't do any window rounding when the free space
2183 : : * is too small.
2184 : : */
2185 [ # # ][ # # ]: 0 : if (window <= free_space - mss || window > free_space)
2186 : 0 : window = (free_space / mss) * mss;
2187 [ # # ][ # # ]: 0 : else if (mss == full_space &&
2188 : 0 : free_space > window + (full_space >> 1))
2189 : : window = free_space;
2190 : : }
2191 : :
2192 : 82360 : return window;
2193 : : }
2194 : :
2195 : : /* Collapses two adjacent SKB's during retransmission. */
2196 : 0 : static void tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
2197 : : {
2198 : : struct tcp_sock *tp = tcp_sk(sk);
2199 : 0 : struct sk_buff *next_skb = tcp_write_queue_next(sk, skb);
2200 : : int skb_size, next_skb_size;
2201 : :
2202 : 0 : skb_size = skb->len;
2203 : 0 : next_skb_size = next_skb->len;
2204 : :
2205 [ # # ][ # # ]: 0 : BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1);
2206 : :
2207 : : tcp_highest_sack_combine(sk, next_skb, skb);
2208 : :
2209 : : tcp_unlink_write_queue(next_skb, sk);
2210 : :
2211 : 0 : skb_copy_from_linear_data(next_skb, skb_put(skb, next_skb_size),
2212 : : next_skb_size);
2213 : :
2214 [ # # ]: 0 : if (next_skb->ip_summed == CHECKSUM_PARTIAL)
2215 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
2216 : :
2217 [ # # ]: 0 : if (skb->ip_summed != CHECKSUM_PARTIAL)
2218 : 0 : skb->csum = csum_block_add(skb->csum, next_skb->csum, skb_size);
2219 : :
2220 : : /* Update sequence range on original skb. */
2221 : 0 : TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(next_skb)->end_seq;
2222 : :
2223 : : /* Merge over control information. This moves PSH/FIN etc. over */
2224 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCP_SKB_CB(next_skb)->tcp_flags;
2225 : :
2226 : : /* All done, get rid of second SKB and account for it so
2227 : : * packet counting does not break.
2228 : : */
2229 : 0 : TCP_SKB_CB(skb)->sacked |= TCP_SKB_CB(next_skb)->sacked & TCPCB_EVER_RETRANS;
2230 : :
2231 : : /* changed transmit queue under us so clear hints */
2232 : : tcp_clear_retrans_hints_partial(tp);
2233 [ # # ]: 0 : if (next_skb == tp->retransmit_skb_hint)
2234 : 0 : tp->retransmit_skb_hint = skb;
2235 : :
2236 : 0 : tcp_adjust_pcount(sk, next_skb, tcp_skb_pcount(next_skb));
2237 : :
2238 : : sk_wmem_free_skb(sk, next_skb);
2239 : 0 : }
2240 : :
2241 : : /* Check if coalescing SKBs is legal. */
2242 : 0 : static bool tcp_can_collapse(const struct sock *sk, const struct sk_buff *skb)
2243 : : {
2244 [ + - ]: 27 : if (tcp_skb_pcount(skb) > 1)
2245 : : return false;
2246 : : /* TODO: SACK collapsing could be used to remove this condition */
2247 [ + - ]: 27 : if (skb_shinfo(skb)->nr_frags != 0)
2248 : : return false;
2249 [ + ]: 27 : if (skb_cloned(skb))
2250 : : return false;
2251 [ + - ]: 27 : if (skb == tcp_send_head(sk))
2252 : : return false;
2253 : : /* Some heurestics for collapsing over SACK'd could be invented */
2254 [ + - ]: 27 : if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
2255 : : return false;
2256 : :
2257 : 27 : return true;
2258 : : }
2259 : :
2260 : : /* Collapse packets in the retransmit queue to make to create
2261 : : * less packets on the wire. This is only done on retransmission.
2262 : : */
2263 : 0 : static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to,
2264 : : int space)
2265 : : {
2266 : : struct tcp_sock *tp = tcp_sk(sk);
2267 : : struct sk_buff *skb = to, *tmp;
2268 : : bool first = true;
2269 : :
2270 [ + - ]: 27 : if (!sysctl_tcp_retrans_collapse)
2271 : : return;
2272 [ + - ]: 27 : if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
2273 : : return;
2274 : :
2275 [ + + ]: 54 : tcp_for_write_queue_from_safe(skb, tmp, sk) {
2276 [ + - ]: 27 : if (!tcp_can_collapse(sk, skb))
2277 : : break;
2278 : :
2279 : 27 : space -= skb->len;
2280 : :
2281 [ + - ]: 27 : if (first) {
2282 : : first = false;
2283 : 27 : continue;
2284 : : }
2285 : :
2286 [ # # ]: 0 : if (space < 0)
2287 : : break;
2288 : : /* Punt if not enough space exists in the first SKB for
2289 : : * the data in the second
2290 : : */
2291 [ # # ]: 0 : if (skb->len > skb_availroom(to))
2292 : : break;
2293 : :
2294 [ # # ]: 0 : if (after(TCP_SKB_CB(skb)->end_seq, tcp_wnd_end(tp)))
2295 : : break;
2296 : :
2297 : 0 : tcp_collapse_retrans(sk, to);
2298 : : }
2299 : : }
2300 : :
2301 : : /* This retransmits one SKB. Policy decisions and retransmit queue
2302 : : * state updates are done by the caller. Returns non-zero if an
2303 : : * error occurred which prevented the send.
2304 : : */
2305 : 0 : int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
2306 : : {
2307 : : struct tcp_sock *tp = tcp_sk(sk);
2308 : : struct inet_connection_sock *icsk = inet_csk(sk);
2309 : : unsigned int cur_mss;
2310 : :
2311 : : /* Inconslusive MTU probe */
2312 [ - + ]: 27 : if (icsk->icsk_mtup.probe_size) {
2313 : 0 : icsk->icsk_mtup.probe_size = 0;
2314 : : }
2315 : :
2316 : : /* Do not sent more than we queued. 1/4 is reserved for possible
2317 : : * copying overhead: fragmentation, tunneling, mangling etc.
2318 : : */
2319 [ + - ]: 27 : if (atomic_read(&sk->sk_wmem_alloc) >
2320 : 27 : min(sk->sk_wmem_queued + (sk->sk_wmem_queued >> 2), sk->sk_sndbuf))
2321 : : return -EAGAIN;
2322 : :
2323 [ - + ]: 27 : if (before(TCP_SKB_CB(skb)->seq, tp->snd_una)) {
2324 [ # # ]: 0 : if (before(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
2325 : 0 : BUG();
2326 [ # # ]: 0 : if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
2327 : : return -ENOMEM;
2328 : : }
2329 : :
2330 [ + - ]: 27 : if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
2331 : : return -EHOSTUNREACH; /* Routing failure or similar. */
2332 : :
2333 : 27 : cur_mss = tcp_current_mss(sk);
2334 : :
2335 : : /* If receiver has shrunk his window, and skb is out of
2336 : : * new window, do not retransmit it. The exception is the
2337 : : * case, when window is shrunk to zero. In this case
2338 : : * our retransmit serves as a zero window probe.
2339 : : */
2340 [ - + ][ # # ]: 27 : if (!before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp)) &&
2341 : : TCP_SKB_CB(skb)->seq != tp->snd_una)
2342 : : return -EAGAIN;
2343 : :
2344 [ - + ]: 27 : if (skb->len > cur_mss) {
2345 [ # # ]: 0 : if (tcp_fragment(sk, skb, cur_mss, cur_mss))
2346 : : return -ENOMEM; /* We'll try again later. */
2347 : : } else {
2348 : : int oldpcount = tcp_skb_pcount(skb);
2349 : :
2350 [ - + ]: 27 : if (unlikely(oldpcount > 1)) {
2351 [ # # ]: 0 : if (skb_unclone(skb, GFP_ATOMIC))
2352 : : return -ENOMEM;
2353 : 0 : tcp_init_tso_segs(sk, skb, cur_mss);
2354 : 0 : tcp_adjust_pcount(sk, skb, oldpcount - tcp_skb_pcount(skb));
2355 : : }
2356 : : }
2357 : :
2358 : 27 : tcp_retrans_try_collapse(sk, skb, cur_mss);
2359 : :
2360 : : /* Make a copy, if the first transmission SKB clone we made
2361 : : * is still in somebody's hands, else make a clone.
2362 : : */
2363 : 27 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
2364 : :
2365 : : /* make sure skb->data is aligned on arches that require it
2366 : : * and check if ack-trimming & collapsing extended the headroom
2367 : : * beyond what csum_start can cover.
2368 : : */
2369 [ + - ][ - + ]: 27 : if (unlikely((NET_IP_ALIGN && ((unsigned long)skb->data & 3)) ||
2370 : : skb_headroom(skb) >= 0xFFFF)) {
2371 : 0 : struct sk_buff *nskb = __pskb_copy(skb, MAX_TCP_HEADER,
2372 : : GFP_ATOMIC);
2373 [ # # ]: 0 : return nskb ? tcp_transmit_skb(sk, nskb, 0, GFP_ATOMIC) :
2374 : : -ENOBUFS;
2375 : : } else {
2376 : 27 : return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
2377 : : }
2378 : : }
2379 : :
2380 : 0 : int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb)
2381 : : {
2382 : : struct tcp_sock *tp = tcp_sk(sk);
2383 : 0 : int err = __tcp_retransmit_skb(sk, skb);
2384 : :
2385 [ # # ]: 0 : if (err == 0) {
2386 : : /* Update global TCP statistics. */
2387 : 0 : TCP_INC_STATS(sock_net(sk), TCP_MIB_RETRANSSEGS);
2388 : :
2389 : 0 : tp->total_retrans++;
2390 : :
2391 : : #if FASTRETRANS_DEBUG > 0
2392 [ # # ]: 0 : if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
2393 : 0 : net_dbg_ratelimited("retrans_out leaked\n");
2394 : : }
2395 : : #endif
2396 [ # # ]: 0 : if (!tp->retrans_out)
2397 : 0 : tp->lost_retrans_low = tp->snd_nxt;
2398 : 0 : TCP_SKB_CB(skb)->sacked |= TCPCB_RETRANS;
2399 : 0 : tp->retrans_out += tcp_skb_pcount(skb);
2400 : :
2401 : : /* Save stamp of the first retransmit. */
2402 [ # # ]: 0 : if (!tp->retrans_stamp)
2403 : 0 : tp->retrans_stamp = TCP_SKB_CB(skb)->when;
2404 : :
2405 : 0 : tp->undo_retrans += tcp_skb_pcount(skb);
2406 : :
2407 : : /* snd_nxt is stored to detect loss of retransmitted segment,
2408 : : * see tcp_input.c tcp_sacktag_write_queue().
2409 : : */
2410 : 0 : TCP_SKB_CB(skb)->ack_seq = tp->snd_nxt;
2411 : : } else {
2412 : 0 : NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
2413 : : }
2414 : 0 : return err;
2415 : : }
2416 : :
2417 : : /* Check if we forward retransmits are possible in the current
2418 : : * window/congestion state.
2419 : : */
2420 : 0 : static bool tcp_can_forward_retransmit(struct sock *sk)
2421 : : {
2422 : : const struct inet_connection_sock *icsk = inet_csk(sk);
2423 : : const struct tcp_sock *tp = tcp_sk(sk);
2424 : :
2425 : : /* Forward retransmissions are possible only during Recovery. */
2426 [ # # ]: 0 : if (icsk->icsk_ca_state != TCP_CA_Recovery)
2427 : : return false;
2428 : :
2429 : : /* No forward retransmissions in Reno are possible. */
2430 [ # # ]: 0 : if (tcp_is_reno(tp))
2431 : : return false;
2432 : :
2433 : : /* Yeah, we have to make difficult choice between forward transmission
2434 : : * and retransmission... Both ways have their merits...
2435 : : *
2436 : : * For now we do not retransmit anything, while we have some new
2437 : : * segments to send. In the other cases, follow rule 3 for
2438 : : * NextSeg() specified in RFC3517.
2439 : : */
2440 : :
2441 [ # # ]: 0 : if (tcp_may_send_now(sk))
2442 : : return false;
2443 : :
2444 : 0 : return true;
2445 : : }
2446 : :
2447 : : /* This gets called after a retransmit timeout, and the initially
2448 : : * retransmitted data is acknowledged. It tries to continue
2449 : : * resending the rest of the retransmit queue, until either
2450 : : * we've sent it all or the congestion window limit is reached.
2451 : : * If doing SACK, the first ACK which comes back for a timeout
2452 : : * based retransmit packet might feed us FACK information again.
2453 : : * If so, we use it to avoid unnecessarily retransmissions.
2454 : : */
2455 : 0 : void tcp_xmit_retransmit_queue(struct sock *sk)
2456 : : {
2457 : : const struct inet_connection_sock *icsk = inet_csk(sk);
2458 : : struct tcp_sock *tp = tcp_sk(sk);
2459 : : struct sk_buff *skb;
2460 : : struct sk_buff *hole = NULL;
2461 : : u32 last_lost;
2462 : : int mib_idx;
2463 : : int fwd_rexmitting = 0;
2464 : :
2465 [ # # ]: 0 : if (!tp->packets_out)
2466 : : return;
2467 : :
2468 [ # # ]: 0 : if (!tp->lost_out)
2469 : 0 : tp->retransmit_high = tp->snd_una;
2470 : :
2471 [ # # ]: 0 : if (tp->retransmit_skb_hint) {
2472 : : skb = tp->retransmit_skb_hint;
2473 : 0 : last_lost = TCP_SKB_CB(skb)->end_seq;
2474 [ # # ]: 0 : if (after(last_lost, tp->retransmit_high))
2475 : : last_lost = tp->retransmit_high;
2476 : : } else {
2477 : : skb = tcp_write_queue_head(sk);
2478 : 0 : last_lost = tp->snd_una;
2479 : : }
2480 : :
2481 [ # # ]: 0 : tcp_for_write_queue_from(skb, sk) {
2482 : 0 : __u8 sacked = TCP_SKB_CB(skb)->sacked;
2483 : :
2484 [ # # ]: 0 : if (skb == tcp_send_head(sk))
2485 : : break;
2486 : : /* we could do better than to assign each time */
2487 [ # # ]: 0 : if (hole == NULL)
2488 : 0 : tp->retransmit_skb_hint = skb;
2489 : :
2490 : : /* Assume this retransmit will generate
2491 : : * only one packet for congestion window
2492 : : * calculation purposes. This works because
2493 : : * tcp_retransmit_skb() will chop up the
2494 : : * packet to be MSS sized and all the
2495 : : * packet counting works out.
2496 : : */
2497 [ # # ]: 0 : if (tcp_packets_in_flight(tp) >= tp->snd_cwnd)
2498 : : return;
2499 : :
2500 [ # # ]: 0 : if (fwd_rexmitting) {
2501 : : begin_fwd:
2502 [ # # ]: 0 : if (!before(TCP_SKB_CB(skb)->seq, tcp_highest_sack_seq(tp)))
2503 : : break;
2504 : : mib_idx = LINUX_MIB_TCPFORWARDRETRANS;
2505 : :
2506 [ # # ]: 0 : } else if (!before(TCP_SKB_CB(skb)->seq, tp->retransmit_high)) {
2507 : 0 : tp->retransmit_high = last_lost;
2508 [ # # ]: 0 : if (!tcp_can_forward_retransmit(sk))
2509 : : break;
2510 : : /* Backtrack if necessary to non-L'ed skb */
2511 [ # # ]: 0 : if (hole != NULL) {
2512 : : skb = hole;
2513 : : hole = NULL;
2514 : : }
2515 : : fwd_rexmitting = 1;
2516 : : goto begin_fwd;
2517 : :
2518 [ # # ]: 0 : } else if (!(sacked & TCPCB_LOST)) {
2519 [ # # ][ # # ]: 0 : if (hole == NULL && !(sacked & (TCPCB_SACKED_RETRANS|TCPCB_SACKED_ACKED)))
2520 : : hole = skb;
2521 : 0 : continue;
2522 : :
2523 : : } else {
2524 : 0 : last_lost = TCP_SKB_CB(skb)->end_seq;
2525 [ # # ]: 0 : if (icsk->icsk_ca_state != TCP_CA_Loss)
2526 : : mib_idx = LINUX_MIB_TCPFASTRETRANS;
2527 : : else
2528 : : mib_idx = LINUX_MIB_TCPSLOWSTARTRETRANS;
2529 : : }
2530 : :
2531 [ # # ]: 0 : if (sacked & (TCPCB_SACKED_ACKED|TCPCB_SACKED_RETRANS))
2532 : 0 : continue;
2533 : :
2534 [ # # ]: 0 : if (tcp_retransmit_skb(sk, skb))
2535 : : return;
2536 : :
2537 : 0 : NET_INC_STATS_BH(sock_net(sk), mib_idx);
2538 : :
2539 [ # # ]: 0 : if (tcp_in_cwnd_reduction(sk))
2540 : 0 : tp->prr_out += tcp_skb_pcount(skb);
2541 : :
2542 [ # # ]: 0 : if (skb == tcp_write_queue_head(sk))
2543 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2544 : 0 : inet_csk(sk)->icsk_rto,
2545 : : TCP_RTO_MAX);
2546 : : }
2547 : : }
2548 : :
2549 : : /* Send a fin. The caller locks the socket for us. This cannot be
2550 : : * allowed to fail queueing a FIN frame under any circumstances.
2551 : : */
2552 : 0 : void tcp_send_fin(struct sock *sk)
2553 : : {
2554 : : struct tcp_sock *tp = tcp_sk(sk);
2555 : : struct sk_buff *skb = tcp_write_queue_tail(sk);
2556 : : int mss_now;
2557 : :
2558 : : /* Optimization, tack on the FIN if we have a queue of
2559 : : * unsent frames. But be careful about outgoing SACKS
2560 : : * and IP options.
2561 : : */
2562 : 33 : mss_now = tcp_current_mss(sk);
2563 : :
2564 [ + - ]: 33 : if (tcp_send_head(sk) != NULL) {
2565 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_FIN;
2566 : 0 : TCP_SKB_CB(skb)->end_seq++;
2567 : 0 : tp->write_seq++;
2568 : : } else {
2569 : : /* Socket is locked, keep trying until memory is available. */
2570 : : for (;;) {
2571 : 33 : skb = alloc_skb_fclone(MAX_TCP_HEADER,
2572 : : sk->sk_allocation);
2573 [ - + ]: 33 : if (skb)
2574 : : break;
2575 : 0 : yield();
2576 : 0 : }
2577 : :
2578 : : /* Reserve space for headers and prepare control bits. */
2579 : : skb_reserve(skb, MAX_TCP_HEADER);
2580 : : /* FIN eats a sequence byte, write_seq advanced by tcp_queue_skb(). */
2581 : 33 : tcp_init_nondata_skb(skb, tp->write_seq,
2582 : : TCPHDR_ACK | TCPHDR_FIN);
2583 : 33 : tcp_queue_skb(sk, skb);
2584 : : }
2585 : 33 : __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_OFF);
2586 : 33 : }
2587 : :
2588 : : /* We get here when a process closes a file descriptor (either due to
2589 : : * an explicit close() or as a byproduct of exit()'ing) and there
2590 : : * was unread data in the receive queue. This behavior is recommended
2591 : : * by RFC 2525, section 2.17. -DaveM
2592 : : */
2593 : 0 : void tcp_send_active_reset(struct sock *sk, gfp_t priority)
2594 : : {
2595 : : struct sk_buff *skb;
2596 : :
2597 : : /* NOTE: No TCP options attached and we never retransmit this. */
2598 : : skb = alloc_skb(MAX_TCP_HEADER, priority);
2599 [ - + ]: 12 : if (!skb) {
2600 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
2601 : 12 : return;
2602 : : }
2603 : :
2604 : : /* Reserve space for headers and prepare control bits. */
2605 : : skb_reserve(skb, MAX_TCP_HEADER);
2606 : : tcp_init_nondata_skb(skb, tcp_acceptable_seq(sk),
2607 : : TCPHDR_ACK | TCPHDR_RST);
2608 : : /* Send it off. */
2609 : 12 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
2610 [ - + ]: 12 : if (tcp_transmit_skb(sk, skb, 0, priority))
2611 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
2612 : :
2613 : 24 : TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTRSTS);
2614 : : }
2615 : :
2616 : : /* Send a crossed SYN-ACK during socket establishment.
2617 : : * WARNING: This routine must only be called when we have already sent
2618 : : * a SYN packet that crossed the incoming SYN that caused this routine
2619 : : * to get called. If this assumption fails then the initial rcv_wnd
2620 : : * and rcv_wscale values will not be correct.
2621 : : */
2622 : 0 : int tcp_send_synack(struct sock *sk)
2623 : : {
2624 : : struct sk_buff *skb;
2625 : :
2626 : : skb = tcp_write_queue_head(sk);
2627 [ # # ][ # # ]: 0 : if (skb == NULL || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
2628 : : pr_debug("%s: wrong queue state\n", __func__);
2629 : : return -EFAULT;
2630 : : }
2631 [ # # ]: 0 : if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {
2632 [ # # ]: 0 : if (skb_cloned(skb)) {
2633 : 0 : struct sk_buff *nskb = skb_copy(skb, GFP_ATOMIC);
2634 [ # # ]: 0 : if (nskb == NULL)
2635 : : return -ENOMEM;
2636 : : tcp_unlink_write_queue(skb, sk);
2637 : : skb_header_release(nskb);
2638 : : __tcp_add_write_queue_head(sk, nskb);
2639 : : sk_wmem_free_skb(sk, skb);
2640 : 0 : sk->sk_wmem_queued += nskb->truesize;
2641 : 0 : sk_mem_charge(sk, nskb->truesize);
2642 : : skb = nskb;
2643 : : }
2644 : :
2645 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
2646 : : TCP_ECN_send_synack(tcp_sk(sk), skb);
2647 : : }
2648 : 0 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
2649 : 0 : return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
2650 : : }
2651 : :
2652 : : /**
2653 : : * tcp_make_synack - Prepare a SYN-ACK.
2654 : : * sk: listener socket
2655 : : * dst: dst entry attached to the SYNACK
2656 : : * req: request_sock pointer
2657 : : *
2658 : : * Allocate one skb and build a SYNACK packet.
2659 : : * @dst is consumed : Caller should not use it again.
2660 : : */
2661 : 0 : struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
2662 : : struct request_sock *req,
2663 : : struct tcp_fastopen_cookie *foc)
2664 : : {
2665 : : struct tcp_out_options opts;
2666 : : struct inet_request_sock *ireq = inet_rsk(req);
2667 : : struct tcp_sock *tp = tcp_sk(sk);
2668 : : struct tcphdr *th;
2669 : : struct sk_buff *skb;
2670 : : struct tcp_md5sig_key *md5;
2671 : : int tcp_header_size;
2672 : : int mss;
2673 : :
2674 : 28 : skb = sock_wmalloc(sk, MAX_TCP_HEADER + 15, 1, GFP_ATOMIC);
2675 [ - + ]: 28 : if (unlikely(!skb)) {
2676 : 0 : dst_release(dst);
2677 : 0 : return NULL;
2678 : : }
2679 : : /* Reserve space for headers. */
2680 : : skb_reserve(skb, MAX_TCP_HEADER);
2681 : :
2682 : : skb_dst_set(skb, dst);
2683 : 28 : security_skb_owned_by(skb, sk);
2684 : :
2685 : 56 : mss = dst_metric_advmss(dst);
2686 [ - + ][ # # ]: 56 : if (tp->rx_opt.user_mss && tp->rx_opt.user_mss < mss)
2687 : : mss = tp->rx_opt.user_mss;
2688 : :
2689 [ + - ]: 28 : if (req->rcv_wnd == 0) { /* ignored for retransmitted syns */
2690 : : __u8 rcv_wscale;
2691 : : /* Set this up on the first call only */
2692 [ + - ]: 28 : req->window_clamp = tp->window_clamp ? : dst_metric(dst, RTAX_WINDOW);
2693 : :
2694 : : /* limit the window selection if the user enforce a smaller rx buffer */
2695 [ - + ][ # # ]: 28 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK &&
2696 [ # # ]: 0 : (req->window_clamp > tcp_full_space(sk) || req->window_clamp == 0))
2697 : 0 : req->window_clamp = tcp_full_space(sk);
2698 : :
2699 : : /* tcp_full_space because it is guaranteed to be the first packet */
2700 : 28 : tcp_select_initial_window(tcp_full_space(sk),
2701 [ - + ]: 28 : mss - (ireq->tstamp_ok ? TCPOLEN_TSTAMP_ALIGNED : 0),
2702 : 28 : &req->rcv_wnd,
2703 : 28 : &req->window_clamp,
2704 : 28 : ireq->wscale_ok,
2705 : : &rcv_wscale,
2706 : : dst_metric(dst, RTAX_INITRWND));
2707 : 28 : ireq->rcv_wscale = rcv_wscale;
2708 : : }
2709 : :
2710 : 28 : memset(&opts, 0, sizeof(opts));
2711 : : #ifdef CONFIG_SYN_COOKIES
2712 [ - + ]: 28 : if (unlikely(req->cookie_ts))
2713 : 0 : TCP_SKB_CB(skb)->when = cookie_init_timestamp(req);
2714 : : else
2715 : : #endif
2716 : 28 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
2717 : 28 : tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, &md5,
2718 : 28 : foc) + sizeof(*th);
2719 : :
2720 : 28 : skb_push(skb, tcp_header_size);
2721 : : skb_reset_transport_header(skb);
2722 : :
2723 : : th = tcp_hdr(skb);
2724 : 28 : memset(th, 0, sizeof(struct tcphdr));
2725 : 28 : th->syn = 1;
2726 : 28 : th->ack = 1;
2727 : : TCP_ECN_make_synack(req, th);
2728 [ - + ]: 28 : th->source = htons(ireq->ir_num);
2729 : 28 : th->dest = ireq->ir_rmt_port;
2730 : : /* Setting of flags are superfluous here for callers (and ECE is
2731 : : * not even correctly set)
2732 : : */
2733 : 28 : tcp_init_nondata_skb(skb, tcp_rsk(req)->snt_isn,
2734 : : TCPHDR_SYN | TCPHDR_ACK);
2735 : :
2736 [ - + ]: 28 : th->seq = htonl(TCP_SKB_CB(skb)->seq);
2737 : : /* XXX data is queued and acked as is. No buffer/window check */
2738 : 56 : th->ack_seq = htonl(tcp_rsk(req)->rcv_nxt);
2739 : :
2740 : : /* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */
2741 : 56 : th->window = htons(min(req->rcv_wnd, 65535U));
2742 : 28 : tcp_options_write((__be32 *)(th + 1), tp, &opts);
2743 : 28 : th->doff = (tcp_header_size >> 2);
2744 : 84 : TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS, tcp_skb_pcount(skb));
2745 : :
2746 : : #ifdef CONFIG_TCP_MD5SIG
2747 : : /* Okay, we have all we need - do the md5 hash if needed */
2748 : : if (md5) {
2749 : : tcp_rsk(req)->af_specific->calc_md5_hash(opts.hash_location,
2750 : : md5, NULL, req, skb);
2751 : : }
2752 : : #endif
2753 : :
2754 : 28 : return skb;
2755 : : }
2756 : : EXPORT_SYMBOL(tcp_make_synack);
2757 : :
2758 : : /* Do all connect socket setups that can be done AF independent. */
2759 : 0 : void tcp_connect_init(struct sock *sk)
2760 : : {
2761 : : const struct dst_entry *dst = __sk_dst_get(sk);
2762 : : struct tcp_sock *tp = tcp_sk(sk);
2763 : : __u8 rcv_wscale;
2764 : :
2765 : : /* We'll fix this up when we get a response from the other end.
2766 : : * See tcp_input.c:tcp_rcv_state_process case TCP_SYN_SENT.
2767 : : */
2768 [ - + ]: 30 : tp->tcp_header_len = sizeof(struct tcphdr) +
2769 : 30 : (sysctl_tcp_timestamps ? TCPOLEN_TSTAMP_ALIGNED : 0);
2770 : :
2771 : : #ifdef CONFIG_TCP_MD5SIG
2772 : : if (tp->af_specific->md5_lookup(sk, sk) != NULL)
2773 : : tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
2774 : : #endif
2775 : :
2776 : : /* If user gave his TCP_MAXSEG, record it to clamp */
2777 [ - + ]: 30 : if (tp->rx_opt.user_mss)
2778 : 0 : tp->rx_opt.mss_clamp = tp->rx_opt.user_mss;
2779 : 30 : tp->max_window = 0;
2780 : 30 : tcp_mtup_init(sk);
2781 : 30 : tcp_sync_mss(sk, dst_mtu(dst));
2782 : :
2783 [ + - ]: 30 : if (!tp->window_clamp)
2784 : 30 : tp->window_clamp = dst_metric(dst, RTAX_WINDOW);
2785 : 30 : tp->advmss = dst_metric_advmss(dst);
2786 [ - + ][ # # ]: 30 : if (tp->rx_opt.user_mss && tp->rx_opt.user_mss < tp->advmss)
2787 : 0 : tp->advmss = tp->rx_opt.user_mss;
2788 : :
2789 : 30 : tcp_initialize_rcv_mss(sk);
2790 : :
2791 : : /* limit the window selection if the user enforce a smaller rx buffer */
2792 [ - + ][ # # ]: 60 : if (sk->sk_userlocks & SOCK_RCVBUF_LOCK &&
2793 [ # # ]: 0 : (tp->window_clamp > tcp_full_space(sk) || tp->window_clamp == 0))
2794 : 0 : tp->window_clamp = tcp_full_space(sk);
2795 : :
2796 : 30 : tcp_select_initial_window(tcp_full_space(sk),
2797 [ - + ]: 30 : tp->advmss - (tp->rx_opt.ts_recent_stamp ? tp->tcp_header_len - sizeof(struct tcphdr) : 0),
2798 : 30 : &tp->rcv_wnd,
2799 : 30 : &tp->window_clamp,
2800 : : sysctl_tcp_window_scaling,
2801 : : &rcv_wscale,
2802 : : dst_metric(dst, RTAX_INITRWND));
2803 : :
2804 : 30 : tp->rx_opt.rcv_wscale = rcv_wscale;
2805 : 30 : tp->rcv_ssthresh = tp->rcv_wnd;
2806 : :
2807 : 30 : sk->sk_err = 0;
2808 : : sock_reset_flag(sk, SOCK_DONE);
2809 : 30 : tp->snd_wnd = 0;
2810 : : tcp_init_wl(tp, 0);
2811 : 30 : tp->snd_una = tp->write_seq;
2812 : 30 : tp->snd_sml = tp->write_seq;
2813 : 30 : tp->snd_up = tp->write_seq;
2814 : 30 : tp->snd_nxt = tp->write_seq;
2815 : :
2816 [ + - ]: 30 : if (likely(!tp->repair))
2817 : 30 : tp->rcv_nxt = 0;
2818 : : else
2819 : 0 : tp->rcv_tstamp = tcp_time_stamp;
2820 : 30 : tp->rcv_wup = tp->rcv_nxt;
2821 : 30 : tp->copied_seq = tp->rcv_nxt;
2822 : :
2823 : 30 : inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT;
2824 : 30 : inet_csk(sk)->icsk_retransmits = 0;
2825 : 30 : tcp_clear_retrans(tp);
2826 : 30 : }
2827 : :
2828 : 0 : static void tcp_connect_queue_skb(struct sock *sk, struct sk_buff *skb)
2829 : : {
2830 : : struct tcp_sock *tp = tcp_sk(sk);
2831 : : struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
2832 : :
2833 : 30 : tcb->end_seq += skb->len;
2834 : : skb_header_release(skb);
2835 : : __tcp_add_write_queue_tail(sk, skb);
2836 : 30 : sk->sk_wmem_queued += skb->truesize;
2837 : 30 : sk_mem_charge(sk, skb->truesize);
2838 : 0 : tp->write_seq = tcb->end_seq;
2839 : 0 : tp->packets_out += tcp_skb_pcount(skb);
2840 : 0 : }
2841 : :
2842 : : /* Build and send a SYN with data and (cached) Fast Open cookie. However,
2843 : : * queue a data-only packet after the regular SYN, such that regular SYNs
2844 : : * are retransmitted on timeouts. Also if the remote SYN-ACK acknowledges
2845 : : * only the SYN sequence, the data are retransmitted in the first ACK.
2846 : : * If cookie is not cached or other error occurs, falls back to send a
2847 : : * regular SYN with Fast Open cookie request option.
2848 : : */
2849 : 0 : static int tcp_send_syn_data(struct sock *sk, struct sk_buff *syn)
2850 : : {
2851 : : struct tcp_sock *tp = tcp_sk(sk);
2852 : 0 : struct tcp_fastopen_request *fo = tp->fastopen_req;
2853 : 0 : int syn_loss = 0, space, i, err = 0, iovlen = fo->data->msg_iovlen;
2854 : : struct sk_buff *syn_data = NULL, *data;
2855 : 0 : unsigned long last_syn_loss = 0;
2856 : :
2857 : 0 : tp->rx_opt.mss_clamp = tp->advmss; /* If MSS is not cached */
2858 : 0 : tcp_fastopen_cache_get(sk, &tp->rx_opt.mss_clamp, &fo->cookie,
2859 : : &syn_loss, &last_syn_loss);
2860 : : /* Recurring FO SYN losses: revert to regular handshake temporarily */
2861 [ # # ]: 0 : if (syn_loss > 1 &&
2862 [ # # ]: 0 : time_before(jiffies, last_syn_loss + (60*HZ << syn_loss))) {
2863 : 0 : fo->cookie.len = -1;
2864 : 0 : goto fallback;
2865 : : }
2866 : :
2867 [ # # ]: 0 : if (sysctl_tcp_fastopen & TFO_CLIENT_NO_COOKIE)
2868 : 0 : fo->cookie.len = -1;
2869 [ # # ]: 0 : else if (fo->cookie.len <= 0)
2870 : : goto fallback;
2871 : :
2872 : : /* MSS for SYN-data is based on cached MSS and bounded by PMTU and
2873 : : * user-MSS. Reserve maximum option space for middleboxes that add
2874 : : * private TCP options. The cost is reduced data space in SYN :(
2875 : : */
2876 [ # # ][ # # ]: 0 : if (tp->rx_opt.user_mss && tp->rx_opt.user_mss < tp->rx_opt.mss_clamp)
2877 : 0 : tp->rx_opt.mss_clamp = tp->rx_opt.user_mss;
2878 : 0 : space = __tcp_mtu_to_mss(sk, inet_csk(sk)->icsk_pmtu_cookie) -
2879 : : MAX_TCP_OPTION_SPACE;
2880 : :
2881 : 0 : syn_data = skb_copy_expand(syn, skb_headroom(syn), space,
2882 : : sk->sk_allocation);
2883 [ # # ]: 0 : if (syn_data == NULL)
2884 : : goto fallback;
2885 : :
2886 [ # # ][ # # ]: 0 : for (i = 0; i < iovlen && syn_data->len < space; ++i) {
2887 : 0 : struct iovec *iov = &fo->data->msg_iov[i];
2888 : 0 : unsigned char __user *from = iov->iov_base;
2889 : 0 : int len = iov->iov_len;
2890 : :
2891 [ # # ]: 0 : if (syn_data->len + len > space)
2892 : 0 : len = space - syn_data->len;
2893 [ # # ]: 0 : else if (i + 1 == iovlen)
2894 : : /* No more data pending in inet_wait_for_connect() */
2895 : 0 : fo->data = NULL;
2896 : :
2897 [ # # ]: 0 : if (skb_add_data(syn_data, from, len))
2898 : : goto fallback;
2899 : : }
2900 : :
2901 : : /* Queue a data-only packet after the regular SYN for retransmission */
2902 : 0 : data = pskb_copy(syn_data, sk->sk_allocation);
2903 [ # # ]: 0 : if (data == NULL)
2904 : : goto fallback;
2905 : 0 : TCP_SKB_CB(data)->seq++;
2906 : 0 : TCP_SKB_CB(data)->tcp_flags &= ~TCPHDR_SYN;
2907 : 0 : TCP_SKB_CB(data)->tcp_flags = (TCPHDR_ACK|TCPHDR_PSH);
2908 : 0 : tcp_connect_queue_skb(sk, data);
2909 : 0 : fo->copied = data->len;
2910 : :
2911 [ # # ]: 0 : if (tcp_transmit_skb(sk, syn_data, 0, sk->sk_allocation) == 0) {
2912 : 0 : tp->syn_data = (fo->copied > 0);
2913 : 0 : NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVE);
2914 : : goto done;
2915 : : }
2916 : : syn_data = NULL;
2917 : :
2918 : : fallback:
2919 : : /* Send a regular SYN with Fast Open cookie request option */
2920 [ # # ]: 0 : if (fo->cookie.len > 0)
2921 : 0 : fo->cookie.len = 0;
2922 : 0 : err = tcp_transmit_skb(sk, syn, 1, sk->sk_allocation);
2923 [ # # ]: 0 : if (err)
2924 : 0 : tp->syn_fastopen = 0;
2925 : 0 : kfree_skb(syn_data);
2926 : : done:
2927 : 0 : fo->cookie.len = -1; /* Exclude Fast Open option for SYN retries */
2928 : 0 : return err;
2929 : : }
2930 : :
2931 : : /* Build a SYN and send it off. */
2932 : 0 : int tcp_connect(struct sock *sk)
2933 : : {
2934 : : struct tcp_sock *tp = tcp_sk(sk);
2935 : : struct sk_buff *buff;
2936 : : int err;
2937 : :
2938 : 30 : tcp_connect_init(sk);
2939 : :
2940 [ - + ]: 30 : if (unlikely(tp->repair)) {
2941 : 0 : tcp_finish_connect(sk, NULL);
2942 : 0 : return 0;
2943 : : }
2944 : :
2945 : 30 : buff = alloc_skb_fclone(MAX_TCP_HEADER + 15, sk->sk_allocation);
2946 [ + - ]: 30 : if (unlikely(buff == NULL))
2947 : : return -ENOBUFS;
2948 : :
2949 : : /* Reserve space for headers. */
2950 : : skb_reserve(buff, MAX_TCP_HEADER);
2951 : :
2952 : 30 : tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
2953 : 30 : tp->retrans_stamp = TCP_SKB_CB(buff)->when = tcp_time_stamp;
2954 : 30 : tcp_connect_queue_skb(sk, buff);
2955 : : TCP_ECN_send_syn(sk, buff);
2956 : :
2957 : : /* Send off SYN; include data in Fast Open. */
2958 [ - + ]: 30 : err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
2959 : 30 : tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
2960 [ + - ]: 30 : if (err == -ECONNREFUSED)
2961 : : return err;
2962 : :
2963 : : /* We change tp->snd_nxt after the tcp_transmit_skb() call
2964 : : * in order to make this packet get counted in tcpOutSegs.
2965 : : */
2966 : 30 : tp->snd_nxt = tp->write_seq;
2967 : 30 : tp->pushed_seq = tp->write_seq;
2968 : 60 : TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);
2969 : :
2970 : : /* Timer for repeating the SYN until an answer. */
2971 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2972 : 30 : inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
2973 : 30 : return 0;
2974 : : }
2975 : : EXPORT_SYMBOL(tcp_connect);
2976 : :
2977 : : /* Send out a delayed ack, the caller does the policy checking
2978 : : * to see if we should even be here. See tcp_input.c:tcp_ack_snd_check()
2979 : : * for details.
2980 : : */
2981 : 0 : void tcp_send_delayed_ack(struct sock *sk)
2982 : : {
2983 : : struct inet_connection_sock *icsk = inet_csk(sk);
2984 : 11259 : int ato = icsk->icsk_ack.ato;
2985 : : unsigned long timeout;
2986 : :
2987 [ + + ]: 11259 : if (ato > TCP_DELACK_MIN) {
2988 : : const struct tcp_sock *tp = tcp_sk(sk);
2989 : : int max_ato = HZ / 2;
2990 : :
2991 [ + + ][ - + ]: 914 : if (icsk->icsk_ack.pingpong ||
2992 : 525 : (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
2993 : : max_ato = TCP_DELACK_MAX;
2994 : :
2995 : : /* Slow path, intersegment interval is "high". */
2996 : :
2997 : : /* If some rtt estimate is known, use it to bound delayed ack.
2998 : : * Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements
2999 : : * directly.
3000 : : */
3001 [ + - ]: 914 : if (tp->srtt) {
3002 : 914 : int rtt = max(tp->srtt >> 3, TCP_DELACK_MIN);
3003 : :
3004 [ + - ]: 914 : if (rtt < max_ato)
3005 : : max_ato = rtt;
3006 : : }
3007 : :
3008 : 914 : ato = min(ato, max_ato);
3009 : : }
3010 : :
3011 : : /* Stay within the limit we were given */
3012 : 0 : timeout = jiffies + ato;
3013 : :
3014 : : /* Use new timeout only if there wasn't a older one earlier. */
3015 [ # # ]: 11259 : if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
3016 : : /* If delack timer was blocked or is about to expire,
3017 : : * send ACK now.
3018 : : */
3019 [ + - ]: 7142 : if (icsk->icsk_ack.blocked ||
3020 [ + + ]: 7142 : time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
3021 : 3 : tcp_send_ack(sk);
3022 : 3 : return;
3023 : : }
3024 : :
3025 [ + + ]: 7139 : if (!time_before(timeout, icsk->icsk_ack.timeout))
3026 : : timeout = icsk->icsk_ack.timeout;
3027 : : }
3028 : 0 : icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
3029 : 0 : icsk->icsk_ack.timeout = timeout;
3030 : 0 : sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
3031 : : }
3032 : :
3033 : : /* This routine sends an ack and also updates the window. */
3034 : 0 : void tcp_send_ack(struct sock *sk)
3035 : : {
3036 : : struct sk_buff *buff;
3037 : :
3038 : : /* If we have been reset, we may not send again. */
3039 [ + - ]: 12737 : if (sk->sk_state == TCP_CLOSE)
3040 : : return;
3041 : :
3042 : : /* We are not putting this on the write queue, so
3043 : : * tcp_transmit_skb() will set the ownership to this
3044 : : * sock.
3045 : : */
3046 : : buff = alloc_skb(MAX_TCP_HEADER, sk_gfp_atomic(sk, GFP_ATOMIC));
3047 [ - + ]: 12737 : if (buff == NULL) {
3048 : : inet_csk_schedule_ack(sk);
3049 : 0 : inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
3050 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
3051 : : TCP_DELACK_MAX, TCP_RTO_MAX);
3052 : : return;
3053 : : }
3054 : :
3055 : : /* Reserve space for headers and prepare control bits. */
3056 : : skb_reserve(buff, MAX_TCP_HEADER);
3057 : : tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);
3058 : :
3059 : : /* Send it off, this clears delayed acks for us. */
3060 : 12737 : TCP_SKB_CB(buff)->when = tcp_time_stamp;
3061 : 12737 : tcp_transmit_skb(sk, buff, 0, sk_gfp_atomic(sk, GFP_ATOMIC));
3062 : : }
3063 : :
3064 : : /* This routine sends a packet with an out of date sequence
3065 : : * number. It assumes the other end will try to ack it.
3066 : : *
3067 : : * Question: what should we make while urgent mode?
3068 : : * 4.4BSD forces sending single byte of data. We cannot send
3069 : : * out of window data, because we have SND.NXT==SND.MAX...
3070 : : *
3071 : : * Current solution: to send TWO zero-length segments in urgent mode:
3072 : : * one is with SEG.SEQ=SND.UNA to deliver urgent pointer, another is
3073 : : * out-of-date with SND.UNA-1 to probe window.
3074 : : */
3075 : 0 : static int tcp_xmit_probe_skb(struct sock *sk, int urgent)
3076 : : {
3077 : : struct tcp_sock *tp = tcp_sk(sk);
3078 : : struct sk_buff *skb;
3079 : :
3080 : : /* We don't queue it, tcp_transmit_skb() sets ownership. */
3081 : : skb = alloc_skb(MAX_TCP_HEADER, sk_gfp_atomic(sk, GFP_ATOMIC));
3082 [ + - ]: 38 : if (skb == NULL)
3083 : : return -1;
3084 : :
3085 : : /* Reserve space for headers and set control bits. */
3086 : : skb_reserve(skb, MAX_TCP_HEADER);
3087 : : /* Use a previous sequence. This should cause the other
3088 : : * end to send an ack. Don't queue or clone SKB, just
3089 : : * send it.
3090 : : */
3091 : 38 : tcp_init_nondata_skb(skb, tp->snd_una - !urgent, TCPHDR_ACK);
3092 : 38 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
3093 : 38 : return tcp_transmit_skb(sk, skb, 0, GFP_ATOMIC);
3094 : : }
3095 : :
3096 : 0 : void tcp_send_window_probe(struct sock *sk)
3097 : : {
3098 [ # # ]: 0 : if (sk->sk_state == TCP_ESTABLISHED) {
3099 : 0 : tcp_sk(sk)->snd_wl1 = tcp_sk(sk)->rcv_nxt - 1;
3100 : 0 : tcp_xmit_probe_skb(sk, 0);
3101 : : }
3102 : 0 : }
3103 : :
3104 : : /* Initiate keepalive or window probe from timer. */
3105 : 0 : int tcp_write_wakeup(struct sock *sk)
3106 : : {
3107 : : struct tcp_sock *tp = tcp_sk(sk);
3108 : : struct sk_buff *skb;
3109 : :
3110 [ + - ]: 38 : if (sk->sk_state == TCP_CLOSE)
3111 : : return -1;
3112 : :
3113 [ - + ][ # # ]: 38 : if ((skb = tcp_send_head(sk)) != NULL &&
3114 : 0 : before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp))) {
3115 : : int err;
3116 : 0 : unsigned int mss = tcp_current_mss(sk);
3117 : 0 : unsigned int seg_size = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
3118 : :
3119 [ # # ]: 0 : if (before(tp->pushed_seq, TCP_SKB_CB(skb)->end_seq))
3120 : 0 : tp->pushed_seq = TCP_SKB_CB(skb)->end_seq;
3121 : :
3122 : : /* We are probing the opening of a window
3123 : : * but the window size is != 0
3124 : : * must have been a result SWS avoidance ( sender )
3125 : : */
3126 [ # # ][ # # ]: 0 : if (seg_size < TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq ||
3127 : 0 : skb->len > mss) {
3128 : 0 : seg_size = min(seg_size, mss);
3129 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
3130 [ # # ]: 0 : if (tcp_fragment(sk, skb, seg_size, mss))
3131 : : return -1;
3132 [ # # ]: 0 : } else if (!tcp_skb_pcount(skb))
3133 : 0 : tcp_set_skb_tso_segs(sk, skb, mss);
3134 : :
3135 : 0 : TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
3136 : 0 : TCP_SKB_CB(skb)->when = tcp_time_stamp;
3137 : 0 : err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
3138 [ # # ]: 0 : if (!err)
3139 : 0 : tcp_event_new_data_sent(sk, skb);
3140 : 0 : return err;
3141 : : } else {
3142 [ - + ]: 38 : if (between(tp->snd_up, tp->snd_una + 1, tp->snd_una + 0xFFFF))
3143 : 0 : tcp_xmit_probe_skb(sk, 1);
3144 : 38 : return tcp_xmit_probe_skb(sk, 0);
3145 : : }
3146 : : }
3147 : :
3148 : : /* A window probe timeout has occurred. If window is not closed send
3149 : : * a partial packet else a zero probe.
3150 : : */
3151 : 0 : void tcp_send_probe0(struct sock *sk)
3152 : : {
3153 : : struct inet_connection_sock *icsk = inet_csk(sk);
3154 : : struct tcp_sock *tp = tcp_sk(sk);
3155 : : int err;
3156 : :
3157 : 0 : err = tcp_write_wakeup(sk);
3158 : :
3159 [ # # ][ # # ]: 0 : if (tp->packets_out || !tcp_send_head(sk)) {
3160 : : /* Cancel probe timer, if it is not required. */
3161 : 0 : icsk->icsk_probes_out = 0;
3162 : 0 : icsk->icsk_backoff = 0;
3163 : 0 : return;
3164 : : }
3165 : :
3166 [ # # ]: 0 : if (err <= 0) {
3167 [ # # ]: 0 : if (icsk->icsk_backoff < sysctl_tcp_retries2)
3168 : 0 : icsk->icsk_backoff++;
3169 : 0 : icsk->icsk_probes_out++;
3170 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3171 : 0 : min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX),
3172 : : TCP_RTO_MAX);
3173 : : } else {
3174 : : /* If packet was not sent due to local congestion,
3175 : : * do not backoff and do not remember icsk_probes_out.
3176 : : * Let local senders to fight for local resources.
3177 : : *
3178 : : * Use accumulated backoff yet.
3179 : : */
3180 [ # # ]: 0 : if (!icsk->icsk_probes_out)
3181 : 0 : icsk->icsk_probes_out = 1;
3182 : : inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3183 : 0 : min(icsk->icsk_rto << icsk->icsk_backoff,
3184 : : TCP_RESOURCE_PROBE_INTERVAL),
3185 : : TCP_RTO_MAX);
3186 : : }
3187 : : }
|
