1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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#include <linux/static_key.h>
45
46#include <trace/events/tcp.h>
47
48static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
49 int push_one, gfp_t gfp);
50
51
52static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb)
53{
54 struct inet_connection_sock *icsk = inet_csk(sk);
55 struct tcp_sock *tp = tcp_sk(sk);
56 unsigned int prior_packets = tp->packets_out;
57
58 tp->snd_nxt = TCP_SKB_CB(skb)->end_seq;
59
60 __skb_unlink(skb, &sk->sk_write_queue);
61 tcp_rbtree_insert(&sk->tcp_rtx_queue, skb);
62
63 tp->packets_out += tcp_skb_pcount(skb);
64 if (!prior_packets || icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
65 tcp_rearm_rto(sk);
66
67 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPORIGDATASENT,
68 tcp_skb_pcount(skb));
69}
70
71
72
73
74
75
76
77
78static inline __u32 tcp_acceptable_seq(const struct sock *sk)
79{
80 const struct tcp_sock *tp = tcp_sk(sk);
81
82 if (!before(tcp_wnd_end(tp), tp->snd_nxt) ||
83 (tp->rx_opt.wscale_ok &&
84 ((tp->snd_nxt - tcp_wnd_end(tp)) < (1 << tp->rx_opt.rcv_wscale))))
85 return tp->snd_nxt;
86 else
87 return tcp_wnd_end(tp);
88}
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104static __u16 tcp_advertise_mss(struct sock *sk)
105{
106 struct tcp_sock *tp = tcp_sk(sk);
107 const struct dst_entry *dst = __sk_dst_get(sk);
108 int mss = tp->advmss;
109
110 if (dst) {
111 unsigned int metric = dst_metric_advmss(dst);
112
113 if (metric < mss) {
114 mss = metric;
115 tp->advmss = mss;
116 }
117 }
118
119 return (__u16)mss;
120}
121
122
123
124
125void tcp_cwnd_restart(struct sock *sk, s32 delta)
126{
127 struct tcp_sock *tp = tcp_sk(sk);
128 u32 restart_cwnd = tcp_init_cwnd(tp, __sk_dst_get(sk));
129 u32 cwnd = tp->snd_cwnd;
130
131 tcp_ca_event(sk, CA_EVENT_CWND_RESTART);
132
133 tp->snd_ssthresh = tcp_current_ssthresh(sk);
134 restart_cwnd = min(restart_cwnd, cwnd);
135
136 while ((delta -= inet_csk(sk)->icsk_rto) > 0 && cwnd > restart_cwnd)
137 cwnd >>= 1;
138 tp->snd_cwnd = max(cwnd, restart_cwnd);
139 tp->snd_cwnd_stamp = tcp_jiffies32;
140 tp->snd_cwnd_used = 0;
141}
142
143
144static void tcp_event_data_sent(struct tcp_sock *tp,
145 struct sock *sk)
146{
147 struct inet_connection_sock *icsk = inet_csk(sk);
148 const u32 now = tcp_jiffies32;
149
150 if (tcp_packets_in_flight(tp) == 0)
151 tcp_ca_event(sk, CA_EVENT_TX_START);
152
153 tp->lsndtime = now;
154
155
156
157
158 if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk->icsk_ack.ato)
159 icsk->icsk_ack.pingpong = 1;
160}
161
162
163static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts)
164{
165 tcp_dec_quickack_mode(sk, pkts);
166 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
167}
168
169
170u32 tcp_default_init_rwnd(u32 mss)
171{
172
173
174
175
176
177 u32 init_rwnd = TCP_INIT_CWND * 2;
178
179 if (mss > 1460)
180 init_rwnd = max((1460 * init_rwnd) / mss, 2U);
181 return init_rwnd;
182}
183
184
185
186
187
188
189
190
191void tcp_select_initial_window(const struct sock *sk, int __space, __u32 mss,
192 __u32 *rcv_wnd, __u32 *window_clamp,
193 int wscale_ok, __u8 *rcv_wscale,
194 __u32 init_rcv_wnd)
195{
196 unsigned int space = (__space < 0 ? 0 : __space);
197
198
199 if (*window_clamp == 0)
200 (*window_clamp) = (U16_MAX << TCP_MAX_WSCALE);
201 space = min(*window_clamp, space);
202
203
204 if (space > mss)
205 space = rounddown(space, mss);
206
207
208
209
210
211
212
213
214
215 if (sock_net(sk)->ipv4.sysctl_tcp_workaround_signed_windows)
216 (*rcv_wnd) = min(space, MAX_TCP_WINDOW);
217 else
218 (*rcv_wnd) = space;
219
220 (*rcv_wscale) = 0;
221 if (wscale_ok) {
222
223 space = max_t(u32, space, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
224 space = max_t(u32, space, sysctl_rmem_max);
225 space = min_t(u32, space, *window_clamp);
226 while (space > U16_MAX && (*rcv_wscale) < TCP_MAX_WSCALE) {
227 space >>= 1;
228 (*rcv_wscale)++;
229 }
230 }
231
232 if (mss > (1 << *rcv_wscale)) {
233 if (!init_rcv_wnd)
234 init_rcv_wnd = tcp_default_init_rwnd(mss);
235 *rcv_wnd = min(*rcv_wnd, init_rcv_wnd * mss);
236 }
237
238
239 (*window_clamp) = min_t(__u32, U16_MAX << (*rcv_wscale), *window_clamp);
240}
241EXPORT_SYMBOL(tcp_select_initial_window);
242
243
244
245
246
247
248static u16 tcp_select_window(struct sock *sk)
249{
250 struct tcp_sock *tp = tcp_sk(sk);
251 u32 old_win = tp->rcv_wnd;
252 u32 cur_win = tcp_receive_window(tp);
253 u32 new_win = __tcp_select_window(sk);
254
255
256 if (new_win < cur_win) {
257
258
259
260
261
262
263
264 if (new_win == 0)
265 NET_INC_STATS(sock_net(sk),
266 LINUX_MIB_TCPWANTZEROWINDOWADV);
267 new_win = ALIGN(cur_win, 1 << tp->rx_opt.rcv_wscale);
268 }
269 tp->rcv_wnd = new_win;
270 tp->rcv_wup = tp->rcv_nxt;
271
272
273
274
275 if (!tp->rx_opt.rcv_wscale &&
276 sock_net(sk)->ipv4.sysctl_tcp_workaround_signed_windows)
277 new_win = min(new_win, MAX_TCP_WINDOW);
278 else
279 new_win = min(new_win, (65535U << tp->rx_opt.rcv_wscale));
280
281
282 new_win >>= tp->rx_opt.rcv_wscale;
283
284
285 if (new_win == 0) {
286 tp->pred_flags = 0;
287 if (old_win)
288 NET_INC_STATS(sock_net(sk),
289 LINUX_MIB_TCPTOZEROWINDOWADV);
290 } else if (old_win == 0) {
291 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFROMZEROWINDOWADV);
292 }
293
294 return new_win;
295}
296
297
298static void tcp_ecn_send_synack(struct sock *sk, struct sk_buff *skb)
299{
300 const struct tcp_sock *tp = tcp_sk(sk);
301
302 TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_CWR;
303 if (!(tp->ecn_flags & TCP_ECN_OK))
304 TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ECE;
305 else if (tcp_ca_needs_ecn(sk) ||
306 tcp_bpf_ca_needs_ecn(sk))
307 INET_ECN_xmit(sk);
308}
309
310
311static void tcp_ecn_send_syn(struct sock *sk, struct sk_buff *skb)
312{
313 struct tcp_sock *tp = tcp_sk(sk);
314 bool bpf_needs_ecn = tcp_bpf_ca_needs_ecn(sk);
315 bool use_ecn = sock_net(sk)->ipv4.sysctl_tcp_ecn == 1 ||
316 tcp_ca_needs_ecn(sk) || bpf_needs_ecn;
317
318 if (!use_ecn) {
319 const struct dst_entry *dst = __sk_dst_get(sk);
320
321 if (dst && dst_feature(dst, RTAX_FEATURE_ECN))
322 use_ecn = true;
323 }
324
325 tp->ecn_flags = 0;
326
327 if (use_ecn) {
328 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
329 tp->ecn_flags = TCP_ECN_OK;
330 if (tcp_ca_needs_ecn(sk) || bpf_needs_ecn)
331 INET_ECN_xmit(sk);
332 }
333}
334
335static void tcp_ecn_clear_syn(struct sock *sk, struct sk_buff *skb)
336{
337 if (sock_net(sk)->ipv4.sysctl_tcp_ecn_fallback)
338
339
340
341 TCP_SKB_CB(skb)->tcp_flags &= ~(TCPHDR_ECE | TCPHDR_CWR);
342}
343
344static void
345tcp_ecn_make_synack(const struct request_sock *req, struct tcphdr *th)
346{
347 if (inet_rsk(req)->ecn_ok)
348 th->ece = 1;
349}
350
351
352
353
354static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb,
355 struct tcphdr *th, int tcp_header_len)
356{
357 struct tcp_sock *tp = tcp_sk(sk);
358
359 if (tp->ecn_flags & TCP_ECN_OK) {
360
361 if (skb->len != tcp_header_len &&
362 !before(TCP_SKB_CB(skb)->seq, tp->snd_nxt)) {
363 INET_ECN_xmit(sk);
364 if (tp->ecn_flags & TCP_ECN_QUEUE_CWR) {
365 tp->ecn_flags &= ~TCP_ECN_QUEUE_CWR;
366 th->cwr = 1;
367 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
368 }
369 } else if (!tcp_ca_needs_ecn(sk)) {
370
371 INET_ECN_dontxmit(sk);
372 }
373 if (tp->ecn_flags & TCP_ECN_DEMAND_CWR)
374 th->ece = 1;
375 }
376}
377
378
379
380
381static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags)
382{
383 skb->ip_summed = CHECKSUM_PARTIAL;
384
385 TCP_SKB_CB(skb)->tcp_flags = flags;
386 TCP_SKB_CB(skb)->sacked = 0;
387
388 tcp_skb_pcount_set(skb, 1);
389
390 TCP_SKB_CB(skb)->seq = seq;
391 if (flags & (TCPHDR_SYN | TCPHDR_FIN))
392 seq++;
393 TCP_SKB_CB(skb)->end_seq = seq;
394}
395
396static inline bool tcp_urg_mode(const struct tcp_sock *tp)
397{
398 return tp->snd_una != tp->snd_up;
399}
400
401#define OPTION_SACK_ADVERTISE (1 << 0)
402#define OPTION_TS (1 << 1)
403#define OPTION_MD5 (1 << 2)
404#define OPTION_WSCALE (1 << 3)
405#define OPTION_FAST_OPEN_COOKIE (1 << 8)
406#define OPTION_SMC (1 << 9)
407
408static void smc_options_write(__be32 *ptr, u16 *options)
409{
410#if IS_ENABLED(CONFIG_SMC)
411 if (static_branch_unlikely(&tcp_have_smc)) {
412 if (unlikely(OPTION_SMC & *options)) {
413 *ptr++ = htonl((TCPOPT_NOP << 24) |
414 (TCPOPT_NOP << 16) |
415 (TCPOPT_EXP << 8) |
416 (TCPOLEN_EXP_SMC_BASE));
417 *ptr++ = htonl(TCPOPT_SMC_MAGIC);
418 }
419 }
420#endif
421}
422
423struct tcp_out_options {
424 u16 options;
425 u16 mss;
426 u8 ws;
427 u8 num_sack_blocks;
428 u8 hash_size;
429 __u8 *hash_location;
430 __u32 tsval, tsecr;
431 struct tcp_fastopen_cookie *fastopen_cookie;
432};
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
448 struct tcp_out_options *opts)
449{
450 u16 options = opts->options;
451
452 if (unlikely(OPTION_MD5 & options)) {
453 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
454 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
455
456 opts->hash_location = (__u8 *)ptr;
457 ptr += 4;
458 }
459
460 if (unlikely(opts->mss)) {
461 *ptr++ = htonl((TCPOPT_MSS << 24) |
462 (TCPOLEN_MSS << 16) |
463 opts->mss);
464 }
465
466 if (likely(OPTION_TS & options)) {
467 if (unlikely(OPTION_SACK_ADVERTISE & options)) {
468 *ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
469 (TCPOLEN_SACK_PERM << 16) |
470 (TCPOPT_TIMESTAMP << 8) |
471 TCPOLEN_TIMESTAMP);
472 options &= ~OPTION_SACK_ADVERTISE;
473 } else {
474 *ptr++ = htonl((TCPOPT_NOP << 24) |
475 (TCPOPT_NOP << 16) |
476 (TCPOPT_TIMESTAMP << 8) |
477 TCPOLEN_TIMESTAMP);
478 }
479 *ptr++ = htonl(opts->tsval);
480 *ptr++ = htonl(opts->tsecr);
481 }
482
483 if (unlikely(OPTION_SACK_ADVERTISE & options)) {
484 *ptr++ = htonl((TCPOPT_NOP << 24) |
485 (TCPOPT_NOP << 16) |
486 (TCPOPT_SACK_PERM << 8) |
487 TCPOLEN_SACK_PERM);
488 }
489
490 if (unlikely(OPTION_WSCALE & options)) {
491 *ptr++ = htonl((TCPOPT_NOP << 24) |
492 (TCPOPT_WINDOW << 16) |
493 (TCPOLEN_WINDOW << 8) |
494 opts->ws);
495 }
496
497 if (unlikely(opts->num_sack_blocks)) {
498 struct tcp_sack_block *sp = tp->rx_opt.dsack ?
499 tp->duplicate_sack : tp->selective_acks;
500 int this_sack;
501
502 *ptr++ = htonl((TCPOPT_NOP << 24) |
503 (TCPOPT_NOP << 16) |
504 (TCPOPT_SACK << 8) |
505 (TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
506 TCPOLEN_SACK_PERBLOCK)));
507
508 for (this_sack = 0; this_sack < opts->num_sack_blocks;
509 ++this_sack) {
510 *ptr++ = htonl(sp[this_sack].start_seq);
511 *ptr++ = htonl(sp[this_sack].end_seq);
512 }
513
514 tp->rx_opt.dsack = 0;
515 }
516
517 if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
518 struct tcp_fastopen_cookie *foc = opts->fastopen_cookie;
519 u8 *p = (u8 *)ptr;
520 u32 len;
521
522 if (foc->exp) {
523 len = TCPOLEN_EXP_FASTOPEN_BASE + foc->len;
524 *ptr = htonl((TCPOPT_EXP << 24) | (len << 16) |
525 TCPOPT_FASTOPEN_MAGIC);
526 p += TCPOLEN_EXP_FASTOPEN_BASE;
527 } else {
528 len = TCPOLEN_FASTOPEN_BASE + foc->len;
529 *p++ = TCPOPT_FASTOPEN;
530 *p++ = len;
531 }
532
533 memcpy(p, foc->val, foc->len);
534 if ((len & 3) == 2) {
535 p[foc->len] = TCPOPT_NOP;
536 p[foc->len + 1] = TCPOPT_NOP;
537 }
538 ptr += (len + 3) >> 2;
539 }
540
541 smc_options_write(ptr, &options);
542}
543
544static void smc_set_option(const struct tcp_sock *tp,
545 struct tcp_out_options *opts,
546 unsigned int *remaining)
547{
548#if IS_ENABLED(CONFIG_SMC)
549 if (static_branch_unlikely(&tcp_have_smc)) {
550 if (tp->syn_smc) {
551 if (*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {
552 opts->options |= OPTION_SMC;
553 *remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;
554 }
555 }
556 }
557#endif
558}
559
560static void smc_set_option_cond(const struct tcp_sock *tp,
561 const struct inet_request_sock *ireq,
562 struct tcp_out_options *opts,
563 unsigned int *remaining)
564{
565#if IS_ENABLED(CONFIG_SMC)
566 if (static_branch_unlikely(&tcp_have_smc)) {
567 if (tp->syn_smc && ireq->smc_ok) {
568 if (*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {
569 opts->options |= OPTION_SMC;
570 *remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;
571 }
572 }
573 }
574#endif
575}
576
577
578
579
580static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
581 struct tcp_out_options *opts,
582 struct tcp_md5sig_key **md5)
583{
584 struct tcp_sock *tp = tcp_sk(sk);
585 unsigned int remaining = MAX_TCP_OPTION_SPACE;
586 struct tcp_fastopen_request *fastopen = tp->fastopen_req;
587
588#ifdef CONFIG_TCP_MD5SIG
589 *md5 = tp->af_specific->md5_lookup(sk, sk);
590 if (*md5) {
591 opts->options |= OPTION_MD5;
592 remaining -= TCPOLEN_MD5SIG_ALIGNED;
593 }
594#else
595 *md5 = NULL;
596#endif
597
598
599
600
601
602
603
604
605
606
607 opts->mss = tcp_advertise_mss(sk);
608 remaining -= TCPOLEN_MSS_ALIGNED;
609
610 if (likely(sock_net(sk)->ipv4.sysctl_tcp_timestamps && !*md5)) {
611 opts->options |= OPTION_TS;
612 opts->tsval = tcp_skb_timestamp(skb) + tp->tsoffset;
613 opts->tsecr = tp->rx_opt.ts_recent;
614 remaining -= TCPOLEN_TSTAMP_ALIGNED;
615 }
616 if (likely(sock_net(sk)->ipv4.sysctl_tcp_window_scaling)) {
617 opts->ws = tp->rx_opt.rcv_wscale;
618 opts->options |= OPTION_WSCALE;
619 remaining -= TCPOLEN_WSCALE_ALIGNED;
620 }
621 if (likely(sock_net(sk)->ipv4.sysctl_tcp_sack)) {
622 opts->options |= OPTION_SACK_ADVERTISE;
623 if (unlikely(!(OPTION_TS & opts->options)))
624 remaining -= TCPOLEN_SACKPERM_ALIGNED;
625 }
626
627 if (fastopen && fastopen->cookie.len >= 0) {
628 u32 need = fastopen->cookie.len;
629
630 need += fastopen->cookie.exp ? TCPOLEN_EXP_FASTOPEN_BASE :
631 TCPOLEN_FASTOPEN_BASE;
632 need = (need + 3) & ~3U;
633 if (remaining >= need) {
634 opts->options |= OPTION_FAST_OPEN_COOKIE;
635 opts->fastopen_cookie = &fastopen->cookie;
636 remaining -= need;
637 tp->syn_fastopen = 1;
638 tp->syn_fastopen_exp = fastopen->cookie.exp ? 1 : 0;
639 }
640 }
641
642 smc_set_option(tp, opts, &remaining);
643
644 return MAX_TCP_OPTION_SPACE - remaining;
645}
646
647
648static unsigned int tcp_synack_options(const struct sock *sk,
649 struct request_sock *req,
650 unsigned int mss, struct sk_buff *skb,
651 struct tcp_out_options *opts,
652 const struct tcp_md5sig_key *md5,
653 struct tcp_fastopen_cookie *foc)
654{
655 struct inet_request_sock *ireq = inet_rsk(req);
656 unsigned int remaining = MAX_TCP_OPTION_SPACE;
657
658#ifdef CONFIG_TCP_MD5SIG
659 if (md5) {
660 opts->options |= OPTION_MD5;
661 remaining -= TCPOLEN_MD5SIG_ALIGNED;
662
663
664
665
666
667
668 ireq->tstamp_ok &= !ireq->sack_ok;
669 }
670#endif
671
672
673 opts->mss = mss;
674 remaining -= TCPOLEN_MSS_ALIGNED;
675
676 if (likely(ireq->wscale_ok)) {
677 opts->ws = ireq->rcv_wscale;
678 opts->options |= OPTION_WSCALE;
679 remaining -= TCPOLEN_WSCALE_ALIGNED;
680 }
681 if (likely(ireq->tstamp_ok)) {
682 opts->options |= OPTION_TS;
683 opts->tsval = tcp_skb_timestamp(skb) + tcp_rsk(req)->ts_off;
684 opts->tsecr = req->ts_recent;
685 remaining -= TCPOLEN_TSTAMP_ALIGNED;
686 }
687 if (likely(ireq->sack_ok)) {
688 opts->options |= OPTION_SACK_ADVERTISE;
689 if (unlikely(!ireq->tstamp_ok))
690 remaining -= TCPOLEN_SACKPERM_ALIGNED;
691 }
692 if (foc != NULL && foc->len >= 0) {
693 u32 need = foc->len;
694
695 need += foc->exp ? TCPOLEN_EXP_FASTOPEN_BASE :
696 TCPOLEN_FASTOPEN_BASE;
697 need = (need + 3) & ~3U;
698 if (remaining >= need) {
699 opts->options |= OPTION_FAST_OPEN_COOKIE;
700 opts->fastopen_cookie = foc;
701 remaining -= need;
702 }
703 }
704
705 smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);
706
707 return MAX_TCP_OPTION_SPACE - remaining;
708}
709
710
711
712
713static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb,
714 struct tcp_out_options *opts,
715 struct tcp_md5sig_key **md5)
716{
717 struct tcp_sock *tp = tcp_sk(sk);
718 unsigned int size = 0;
719 unsigned int eff_sacks;
720
721 opts->options = 0;
722
723#ifdef CONFIG_TCP_MD5SIG
724 *md5 = tp->af_specific->md5_lookup(sk, sk);
725 if (unlikely(*md5)) {
726 opts->options |= OPTION_MD5;
727 size += TCPOLEN_MD5SIG_ALIGNED;
728 }
729#else
730 *md5 = NULL;
731#endif
732
733 if (likely(tp->rx_opt.tstamp_ok)) {
734 opts->options |= OPTION_TS;
735 opts->tsval = skb ? tcp_skb_timestamp(skb) + tp->tsoffset : 0;
736 opts->tsecr = tp->rx_opt.ts_recent;
737 size += TCPOLEN_TSTAMP_ALIGNED;
738 }
739
740 eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
741 if (unlikely(eff_sacks)) {
742 const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
743 opts->num_sack_blocks =
744 min_t(unsigned int, eff_sacks,
745 (remaining - TCPOLEN_SACK_BASE_ALIGNED) /
746 TCPOLEN_SACK_PERBLOCK);
747 size += TCPOLEN_SACK_BASE_ALIGNED +
748 opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
749 }
750
751 return size;
752}
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769struct tsq_tasklet {
770 struct tasklet_struct tasklet;
771 struct list_head head;
772};
773static DEFINE_PER_CPU(struct tsq_tasklet, tsq_tasklet);
774
775static void tcp_tsq_handler(struct sock *sk)
776{
777 if ((1 << sk->sk_state) &
778 (TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_CLOSING |
779 TCPF_CLOSE_WAIT | TCPF_LAST_ACK)) {
780 struct tcp_sock *tp = tcp_sk(sk);
781
782 if (tp->lost_out > tp->retrans_out &&
783 tp->snd_cwnd > tcp_packets_in_flight(tp)) {
784 tcp_mstamp_refresh(tp);
785 tcp_xmit_retransmit_queue(sk);
786 }
787
788 tcp_write_xmit(sk, tcp_current_mss(sk), tp->nonagle,
789 0, GFP_ATOMIC);
790 }
791}
792
793
794
795
796
797
798static void tcp_tasklet_func(unsigned long data)
799{
800 struct tsq_tasklet *tsq = (struct tsq_tasklet *)data;
801 LIST_HEAD(list);
802 unsigned long flags;
803 struct list_head *q, *n;
804 struct tcp_sock *tp;
805 struct sock *sk;
806
807 local_irq_save(flags);
808 list_splice_init(&tsq->head, &list);
809 local_irq_restore(flags);
810
811 list_for_each_safe(q, n, &list) {
812 tp = list_entry(q, struct tcp_sock, tsq_node);
813 list_del(&tp->tsq_node);
814
815 sk = (struct sock *)tp;
816 smp_mb__before_atomic();
817 clear_bit(TSQ_QUEUED, &sk->sk_tsq_flags);
818
819 if (!sk->sk_lock.owned &&
820 test_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags)) {
821 bh_lock_sock(sk);
822 if (!sock_owned_by_user(sk)) {
823 clear_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags);
824 tcp_tsq_handler(sk);
825 }
826 bh_unlock_sock(sk);
827 }
828
829 sk_free(sk);
830 }
831}
832
833#define TCP_DEFERRED_ALL (TCPF_TSQ_DEFERRED | \
834 TCPF_WRITE_TIMER_DEFERRED | \
835 TCPF_DELACK_TIMER_DEFERRED | \
836 TCPF_MTU_REDUCED_DEFERRED)
837
838
839
840
841
842
843
844void tcp_release_cb(struct sock *sk)
845{
846 unsigned long flags, nflags;
847
848
849 do {
850 flags = sk->sk_tsq_flags;
851 if (!(flags & TCP_DEFERRED_ALL))
852 return;
853 nflags = flags & ~TCP_DEFERRED_ALL;
854 } while (cmpxchg(&sk->sk_tsq_flags, flags, nflags) != flags);
855
856 if (flags & TCPF_TSQ_DEFERRED)
857 tcp_tsq_handler(sk);
858
859
860
861
862
863
864
865
866
867
868 sock_release_ownership(sk);
869
870 if (flags & TCPF_WRITE_TIMER_DEFERRED) {
871 tcp_write_timer_handler(sk);
872 __sock_put(sk);
873 }
874 if (flags & TCPF_DELACK_TIMER_DEFERRED) {
875 tcp_delack_timer_handler(sk);
876 __sock_put(sk);
877 }
878 if (flags & TCPF_MTU_REDUCED_DEFERRED) {
879 inet_csk(sk)->icsk_af_ops->mtu_reduced(sk);
880 __sock_put(sk);
881 }
882}
883EXPORT_SYMBOL(tcp_release_cb);
884
885void __init tcp_tasklet_init(void)
886{
887 int i;
888
889 for_each_possible_cpu(i) {
890 struct tsq_tasklet *tsq = &per_cpu(tsq_tasklet, i);
891
892 INIT_LIST_HEAD(&tsq->head);
893 tasklet_init(&tsq->tasklet,
894 tcp_tasklet_func,
895 (unsigned long)tsq);
896 }
897}
898
899
900
901
902
903
904void tcp_wfree(struct sk_buff *skb)
905{
906 struct sock *sk = skb->sk;
907 struct tcp_sock *tp = tcp_sk(sk);
908 unsigned long flags, nval, oval;
909
910
911
912
913 WARN_ON(refcount_sub_and_test(skb->truesize - 1, &sk->sk_wmem_alloc));
914
915
916
917
918
919
920
921
922 if (refcount_read(&sk->sk_wmem_alloc) >= SKB_TRUESIZE(1) && this_cpu_ksoftirqd() == current)
923 goto out;
924
925 for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) {
926 struct tsq_tasklet *tsq;
927 bool empty;
928
929 if (!(oval & TSQF_THROTTLED) || (oval & TSQF_QUEUED))
930 goto out;
931
932 nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED;
933 nval = cmpxchg(&sk->sk_tsq_flags, oval, nval);
934 if (nval != oval)
935 continue;
936
937
938 local_irq_save(flags);
939 tsq = this_cpu_ptr(&tsq_tasklet);
940 empty = list_empty(&tsq->head);
941 list_add(&tp->tsq_node, &tsq->head);
942 if (empty)
943 tasklet_schedule(&tsq->tasklet);
944 local_irq_restore(flags);
945 return;
946 }
947out:
948 sk_free(sk);
949}
950
951
952
953
954enum hrtimer_restart tcp_pace_kick(struct hrtimer *timer)
955{
956 struct tcp_sock *tp = container_of(timer, struct tcp_sock, pacing_timer);
957 struct sock *sk = (struct sock *)tp;
958 unsigned long nval, oval;
959
960 for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) {
961 struct tsq_tasklet *tsq;
962 bool empty;
963
964 if (oval & TSQF_QUEUED)
965 break;
966
967 nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED;
968 nval = cmpxchg(&sk->sk_tsq_flags, oval, nval);
969 if (nval != oval)
970 continue;
971
972 if (!refcount_inc_not_zero(&sk->sk_wmem_alloc))
973 break;
974
975 tsq = this_cpu_ptr(&tsq_tasklet);
976 empty = list_empty(&tsq->head);
977 list_add(&tp->tsq_node, &tsq->head);
978 if (empty)
979 tasklet_schedule(&tsq->tasklet);
980 break;
981 }
982 return HRTIMER_NORESTART;
983}
984
985
986
987
988
989
990
991static bool tcp_needs_internal_pacing(const struct sock *sk)
992{
993 return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED;
994}
995
996static void tcp_internal_pacing(struct sock *sk, const struct sk_buff *skb)
997{
998 u64 len_ns;
999 u32 rate;
1000
1001 if (!tcp_needs_internal_pacing(sk))
1002 return;
1003 rate = sk->sk_pacing_rate;
1004 if (!rate || rate == ~0U)
1005 return;
1006
1007
1008
1009
1010 len_ns = (u64)skb->len * NSEC_PER_SEC;
1011 do_div(len_ns, rate);
1012 hrtimer_start(&tcp_sk(sk)->pacing_timer,
1013 ktime_add_ns(ktime_get(), len_ns),
1014 HRTIMER_MODE_ABS_PINNED);
1015}
1016
1017static void tcp_update_skb_after_send(struct tcp_sock *tp, struct sk_buff *skb)
1018{
1019 skb->skb_mstamp = tp->tcp_mstamp;
1020 list_move_tail(&skb->tcp_tsorted_anchor, &tp->tsorted_sent_queue);
1021}
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
1035 gfp_t gfp_mask)
1036{
1037 const struct inet_connection_sock *icsk = inet_csk(sk);
1038 struct inet_sock *inet;
1039 struct tcp_sock *tp;
1040 struct tcp_skb_cb *tcb;
1041 struct tcp_out_options opts;
1042 unsigned int tcp_options_size, tcp_header_size;
1043 struct sk_buff *oskb = NULL;
1044 struct tcp_md5sig_key *md5;
1045 struct tcphdr *th;
1046 int err;
1047
1048 BUG_ON(!skb || !tcp_skb_pcount(skb));
1049 tp = tcp_sk(sk);
1050
1051 if (clone_it) {
1052 TCP_SKB_CB(skb)->tx.in_flight = TCP_SKB_CB(skb)->end_seq
1053 - tp->snd_una;
1054 oskb = skb;
1055
1056 tcp_skb_tsorted_save(oskb) {
1057 if (unlikely(skb_cloned(oskb)))
1058 skb = pskb_copy(oskb, gfp_mask);
1059 else
1060 skb = skb_clone(oskb, gfp_mask);
1061 } tcp_skb_tsorted_restore(oskb);
1062
1063 if (unlikely(!skb))
1064 return -ENOBUFS;
1065 }
1066 skb->skb_mstamp = tp->tcp_mstamp;
1067
1068 inet = inet_sk(sk);
1069 tcb = TCP_SKB_CB(skb);
1070 memset(&opts, 0, sizeof(opts));
1071
1072 if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
1073 tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
1074 else
1075 tcp_options_size = tcp_established_options(sk, skb, &opts,
1076 &md5);
1077 tcp_header_size = tcp_options_size + sizeof(struct tcphdr);
1078
1079
1080
1081
1082
1083
1084
1085
1086 skb->ooo_okay = sk_wmem_alloc_get(sk) < SKB_TRUESIZE(1);
1087
1088
1089
1090
1091
1092
1093 skb->pfmemalloc = 0;
1094
1095 skb_push(skb, tcp_header_size);
1096 skb_reset_transport_header(skb);
1097
1098 skb_orphan(skb);
1099 skb->sk = sk;
1100 skb->destructor = skb_is_tcp_pure_ack(skb) ? __sock_wfree : tcp_wfree;
1101 skb_set_hash_from_sk(skb, sk);
1102 refcount_add(skb->truesize, &sk->sk_wmem_alloc);
1103
1104 skb_set_dst_pending_confirm(skb, sk->sk_dst_pending_confirm);
1105
1106
1107 th = (struct tcphdr *)skb->data;
1108 th->source = inet->inet_sport;
1109 th->dest = inet->inet_dport;
1110 th->seq = htonl(tcb->seq);
1111 th->ack_seq = htonl(tp->rcv_nxt);
1112 *(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) |
1113 tcb->tcp_flags);
1114
1115 th->check = 0;
1116 th->urg_ptr = 0;
1117
1118
1119 if (unlikely(tcp_urg_mode(tp) && before(tcb->seq, tp->snd_up))) {
1120 if (before(tp->snd_up, tcb->seq + 0x10000)) {
1121 th->urg_ptr = htons(tp->snd_up - tcb->seq);
1122 th->urg = 1;
1123 } else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
1124 th->urg_ptr = htons(0xFFFF);
1125 th->urg = 1;
1126 }
1127 }
1128
1129 tcp_options_write((__be32 *)(th + 1), tp, &opts);
1130 skb_shinfo(skb)->gso_type = sk->sk_gso_type;
1131 if (likely(!(tcb->tcp_flags & TCPHDR_SYN))) {
1132 th->window = htons(tcp_select_window(sk));
1133 tcp_ecn_send(sk, skb, th, tcp_header_size);
1134 } else {
1135
1136
1137
1138 th->window = htons(min(tp->rcv_wnd, 65535U));
1139 }
1140#ifdef CONFIG_TCP_MD5SIG
1141
1142 if (md5) {
1143 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
1144 tp->af_specific->calc_md5_hash(opts.hash_location,
1145 md5, sk, skb);
1146 }
1147#endif
1148
1149 icsk->icsk_af_ops->send_check(sk, skb);
1150
1151 if (likely(tcb->tcp_flags & TCPHDR_ACK))
1152 tcp_event_ack_sent(sk, tcp_skb_pcount(skb));
1153
1154 if (skb->len != tcp_header_size) {
1155 tcp_event_data_sent(tp, sk);
1156 tp->data_segs_out += tcp_skb_pcount(skb);
1157 tcp_internal_pacing(sk, skb);
1158 }
1159
1160 if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
1161 TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
1162 tcp_skb_pcount(skb));
1163
1164 tp->segs_out += tcp_skb_pcount(skb);
1165
1166 skb_shinfo(skb)->gso_segs = tcp_skb_pcount(skb);
1167 skb_shinfo(skb)->gso_size = tcp_skb_mss(skb);
1168
1169
1170 skb->tstamp = 0;
1171
1172
1173 memset(skb->cb, 0, max(sizeof(struct inet_skb_parm),
1174 sizeof(struct inet6_skb_parm)));
1175
1176 err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl);
1177
1178 if (unlikely(err > 0)) {
1179 tcp_enter_cwr(sk);
1180 err = net_xmit_eval(err);
1181 }
1182 if (!err && oskb) {
1183 tcp_update_skb_after_send(tp, oskb);
1184 tcp_rate_skb_sent(sk, oskb);
1185 }
1186 return err;
1187}
1188
1189
1190
1191
1192
1193
1194static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb)
1195{
1196 struct tcp_sock *tp = tcp_sk(sk);
1197
1198
1199 tp->write_seq = TCP_SKB_CB(skb)->end_seq;
1200 __skb_header_release(skb);
1201 tcp_add_write_queue_tail(sk, skb);
1202 sk->sk_wmem_queued += skb->truesize;
1203 sk_mem_charge(sk, skb->truesize);
1204}
1205
1206
1207static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now)
1208{
1209 if (skb->len <= mss_now) {
1210
1211
1212
1213 tcp_skb_pcount_set(skb, 1);
1214 TCP_SKB_CB(skb)->tcp_gso_size = 0;
1215 } else {
1216 tcp_skb_pcount_set(skb, DIV_ROUND_UP(skb->len, mss_now));
1217 TCP_SKB_CB(skb)->tcp_gso_size = mss_now;
1218 }
1219}
1220
1221
1222
1223
1224static void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr)
1225{
1226 struct tcp_sock *tp = tcp_sk(sk);
1227
1228 tp->packets_out -= decr;
1229
1230 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
1231 tp->sacked_out -= decr;
1232 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)
1233 tp->retrans_out -= decr;
1234 if (TCP_SKB_CB(skb)->sacked & TCPCB_LOST)
1235 tp->lost_out -= decr;
1236
1237
1238 if (tcp_is_reno(tp) && decr > 0)
1239 tp->sacked_out -= min_t(u32, tp->sacked_out, decr);
1240
1241 if (tp->lost_skb_hint &&
1242 before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(tp->lost_skb_hint)->seq) &&
1243 (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
1244 tp->lost_cnt_hint -= decr;
1245
1246 tcp_verify_left_out(tp);
1247}
1248
1249static bool tcp_has_tx_tstamp(const struct sk_buff *skb)
1250{
1251 return TCP_SKB_CB(skb)->txstamp_ack ||
1252 (skb_shinfo(skb)->tx_flags & SKBTX_ANY_TSTAMP);
1253}
1254
1255static void tcp_fragment_tstamp(struct sk_buff *skb, struct sk_buff *skb2)
1256{
1257 struct skb_shared_info *shinfo = skb_shinfo(skb);
1258
1259 if (unlikely(tcp_has_tx_tstamp(skb)) &&
1260 !before(shinfo->tskey, TCP_SKB_CB(skb2)->seq)) {
1261 struct skb_shared_info *shinfo2 = skb_shinfo(skb2);
1262 u8 tsflags = shinfo->tx_flags & SKBTX_ANY_TSTAMP;
1263
1264 shinfo->tx_flags &= ~tsflags;
1265 shinfo2->tx_flags |= tsflags;
1266 swap(shinfo->tskey, shinfo2->tskey);
1267 TCP_SKB_CB(skb2)->txstamp_ack = TCP_SKB_CB(skb)->txstamp_ack;
1268 TCP_SKB_CB(skb)->txstamp_ack = 0;
1269 }
1270}
1271
1272static void tcp_skb_fragment_eor(struct sk_buff *skb, struct sk_buff *skb2)
1273{
1274 TCP_SKB_CB(skb2)->eor = TCP_SKB_CB(skb)->eor;
1275 TCP_SKB_CB(skb)->eor = 0;
1276}
1277
1278
1279static void tcp_insert_write_queue_after(struct sk_buff *skb,
1280 struct sk_buff *buff,
1281 struct sock *sk,
1282 enum tcp_queue tcp_queue)
1283{
1284 if (tcp_queue == TCP_FRAG_IN_WRITE_QUEUE)
1285 __skb_queue_after(&sk->sk_write_queue, skb, buff);
1286 else
1287 tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);
1288}
1289
1290
1291
1292
1293
1294
1295int tcp_fragment(struct sock *sk, enum tcp_queue tcp_queue,
1296 struct sk_buff *skb, u32 len,
1297 unsigned int mss_now, gfp_t gfp)
1298{
1299 struct tcp_sock *tp = tcp_sk(sk);
1300 struct sk_buff *buff;
1301 int nsize, old_factor;
1302 int nlen;
1303 u8 flags;
1304
1305 if (WARN_ON(len > skb->len))
1306 return -EINVAL;
1307
1308 nsize = skb_headlen(skb) - len;
1309 if (nsize < 0)
1310 nsize = 0;
1311
1312 if (skb_unclone(skb, gfp))
1313 return -ENOMEM;
1314
1315
1316 buff = sk_stream_alloc_skb(sk, nsize, gfp, true);
1317 if (!buff)
1318 return -ENOMEM;
1319
1320 sk->sk_wmem_queued += buff->truesize;
1321 sk_mem_charge(sk, buff->truesize);
1322 nlen = skb->len - len - nsize;
1323 buff->truesize += nlen;
1324 skb->truesize -= nlen;
1325
1326
1327 TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
1328 TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
1329 TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
1330
1331
1332 flags = TCP_SKB_CB(skb)->tcp_flags;
1333 TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
1334 TCP_SKB_CB(buff)->tcp_flags = flags;
1335 TCP_SKB_CB(buff)->sacked = TCP_SKB_CB(skb)->sacked;
1336 tcp_skb_fragment_eor(skb, buff);
1337
1338 skb_split(skb, buff, len);
1339
1340 buff->ip_summed = CHECKSUM_PARTIAL;
1341
1342 buff->tstamp = skb->tstamp;
1343 tcp_fragment_tstamp(skb, buff);
1344
1345 old_factor = tcp_skb_pcount(skb);
1346
1347
1348 tcp_set_skb_tso_segs(skb, mss_now);
1349 tcp_set_skb_tso_segs(buff, mss_now);
1350
1351
1352 TCP_SKB_CB(buff)->tx = TCP_SKB_CB(skb)->tx;
1353
1354
1355
1356
1357 if (!before(tp->snd_nxt, TCP_SKB_CB(buff)->end_seq)) {
1358 int diff = old_factor - tcp_skb_pcount(skb) -
1359 tcp_skb_pcount(buff);
1360
1361 if (diff)
1362 tcp_adjust_pcount(sk, skb, diff);
1363 }
1364
1365
1366 __skb_header_release(buff);
1367 tcp_insert_write_queue_after(skb, buff, sk, tcp_queue);
1368 if (tcp_queue == TCP_FRAG_IN_RTX_QUEUE)
1369 list_add(&buff->tcp_tsorted_anchor, &skb->tcp_tsorted_anchor);
1370
1371 return 0;
1372}
1373
1374
1375
1376
1377static int __pskb_trim_head(struct sk_buff *skb, int len)
1378{
1379 struct skb_shared_info *shinfo;
1380 int i, k, eat;
1381
1382 eat = min_t(int, len, skb_headlen(skb));
1383 if (eat) {
1384 __skb_pull(skb, eat);
1385 len -= eat;
1386 if (!len)
1387 return 0;
1388 }
1389 eat = len;
1390 k = 0;
1391 shinfo = skb_shinfo(skb);
1392 for (i = 0; i < shinfo->nr_frags; i++) {
1393 int size = skb_frag_size(&shinfo->frags[i]);
1394
1395 if (size <= eat) {
1396 skb_frag_unref(skb, i);
1397 eat -= size;
1398 } else {
1399 shinfo->frags[k] = shinfo->frags[i];
1400 if (eat) {
1401 shinfo->frags[k].page_offset += eat;
1402 skb_frag_size_sub(&shinfo->frags[k], eat);
1403 eat = 0;
1404 }
1405 k++;
1406 }
1407 }
1408 shinfo->nr_frags = k;
1409
1410 skb->data_len -= len;
1411 skb->len = skb->data_len;
1412 return len;
1413}
1414
1415
1416int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len)
1417{
1418 u32 delta_truesize;
1419
1420 if (skb_unclone(skb, GFP_ATOMIC))
1421 return -ENOMEM;
1422
1423 delta_truesize = __pskb_trim_head(skb, len);
1424
1425 TCP_SKB_CB(skb)->seq += len;
1426 skb->ip_summed = CHECKSUM_PARTIAL;
1427
1428 if (delta_truesize) {
1429 skb->truesize -= delta_truesize;
1430 sk->sk_wmem_queued -= delta_truesize;
1431 sk_mem_uncharge(sk, delta_truesize);
1432 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
1433 }
1434
1435
1436 if (tcp_skb_pcount(skb) > 1)
1437 tcp_set_skb_tso_segs(skb, tcp_skb_mss(skb));
1438
1439 return 0;
1440}
1441
1442
1443static inline int __tcp_mtu_to_mss(struct sock *sk, int pmtu)
1444{
1445 const struct tcp_sock *tp = tcp_sk(sk);
1446 const struct inet_connection_sock *icsk = inet_csk(sk);
1447 int mss_now;
1448
1449
1450
1451
1452 mss_now = pmtu - icsk->icsk_af_ops->net_header_len - sizeof(struct tcphdr);
1453
1454
1455 if (icsk->icsk_af_ops->net_frag_header_len) {
1456 const struct dst_entry *dst = __sk_dst_get(sk);
1457
1458 if (dst && dst_allfrag(dst))
1459 mss_now -= icsk->icsk_af_ops->net_frag_header_len;
1460 }
1461
1462
1463 if (mss_now > tp->rx_opt.mss_clamp)
1464 mss_now = tp->rx_opt.mss_clamp;
1465
1466
1467 mss_now -= icsk->icsk_ext_hdr_len;
1468
1469
1470 if (mss_now < 48)
1471 mss_now = 48;
1472 return mss_now;
1473}
1474
1475
1476int tcp_mtu_to_mss(struct sock *sk, int pmtu)
1477{
1478
1479 return __tcp_mtu_to_mss(sk, pmtu) -
1480 (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr));
1481}
1482
1483
1484int tcp_mss_to_mtu(struct sock *sk, int mss)
1485{
1486 const struct tcp_sock *tp = tcp_sk(sk);
1487 const struct inet_connection_sock *icsk = inet_csk(sk);
1488 int mtu;
1489
1490 mtu = mss +
1491 tp->tcp_header_len +
1492 icsk->icsk_ext_hdr_len +
1493 icsk->icsk_af_ops->net_header_len;
1494
1495
1496 if (icsk->icsk_af_ops->net_frag_header_len) {
1497 const struct dst_entry *dst = __sk_dst_get(sk);
1498
1499 if (dst && dst_allfrag(dst))
1500 mtu += icsk->icsk_af_ops->net_frag_header_len;
1501 }
1502 return mtu;
1503}
1504EXPORT_SYMBOL(tcp_mss_to_mtu);
1505
1506
1507void tcp_mtup_init(struct sock *sk)
1508{
1509 struct tcp_sock *tp = tcp_sk(sk);
1510 struct inet_connection_sock *icsk = inet_csk(sk);
1511 struct net *net = sock_net(sk);
1512
1513 icsk->icsk_mtup.enabled = net->ipv4.sysctl_tcp_mtu_probing > 1;
1514 icsk->icsk_mtup.search_high = tp->rx_opt.mss_clamp + sizeof(struct tcphdr) +
1515 icsk->icsk_af_ops->net_header_len;
1516 icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, net->ipv4.sysctl_tcp_base_mss);
1517 icsk->icsk_mtup.probe_size = 0;
1518 if (icsk->icsk_mtup.enabled)
1519 icsk->icsk_mtup.probe_timestamp = tcp_jiffies32;
1520}
1521EXPORT_SYMBOL(tcp_mtup_init);
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu)
1546{
1547 struct tcp_sock *tp = tcp_sk(sk);
1548 struct inet_connection_sock *icsk = inet_csk(sk);
1549 int mss_now;
1550
1551 if (icsk->icsk_mtup.search_high > pmtu)
1552 icsk->icsk_mtup.search_high = pmtu;
1553
1554 mss_now = tcp_mtu_to_mss(sk, pmtu);
1555 mss_now = tcp_bound_to_half_wnd(tp, mss_now);
1556
1557
1558 icsk->icsk_pmtu_cookie = pmtu;
1559 if (icsk->icsk_mtup.enabled)
1560 mss_now = min(mss_now, tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low));
1561 tp->mss_cache = mss_now;
1562
1563 return mss_now;
1564}
1565EXPORT_SYMBOL(tcp_sync_mss);
1566
1567
1568
1569
1570unsigned int tcp_current_mss(struct sock *sk)
1571{
1572 const struct tcp_sock *tp = tcp_sk(sk);
1573 const struct dst_entry *dst = __sk_dst_get(sk);
1574 u32 mss_now;
1575 unsigned int header_len;
1576 struct tcp_out_options opts;
1577 struct tcp_md5sig_key *md5;
1578
1579 mss_now = tp->mss_cache;
1580
1581 if (dst) {
1582 u32 mtu = dst_mtu(dst);
1583 if (mtu != inet_csk(sk)->icsk_pmtu_cookie)
1584 mss_now = tcp_sync_mss(sk, mtu);
1585 }
1586
1587 header_len = tcp_established_options(sk, NULL, &opts, &md5) +
1588 sizeof(struct tcphdr);
1589
1590
1591
1592
1593 if (header_len != tp->tcp_header_len) {
1594 int delta = (int) header_len - tp->tcp_header_len;
1595 mss_now -= delta;
1596 }
1597
1598 return mss_now;
1599}
1600
1601
1602
1603
1604
1605static void tcp_cwnd_application_limited(struct sock *sk)
1606{
1607 struct tcp_sock *tp = tcp_sk(sk);
1608
1609 if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
1610 sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
1611
1612 u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
1613 u32 win_used = max(tp->snd_cwnd_used, init_win);
1614 if (win_used < tp->snd_cwnd) {
1615 tp->snd_ssthresh = tcp_current_ssthresh(sk);
1616 tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
1617 }
1618 tp->snd_cwnd_used = 0;
1619 }
1620 tp->snd_cwnd_stamp = tcp_jiffies32;
1621}
1622
1623static void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited)
1624{
1625 const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
1626 struct tcp_sock *tp = tcp_sk(sk);
1627
1628
1629
1630
1631 if (!before(tp->snd_una, tp->max_packets_seq) ||
1632 tp->packets_out > tp->max_packets_out) {
1633 tp->max_packets_out = tp->packets_out;
1634 tp->max_packets_seq = tp->snd_nxt;
1635 tp->is_cwnd_limited = is_cwnd_limited;
1636 }
1637
1638 if (tcp_is_cwnd_limited(sk)) {
1639
1640 tp->snd_cwnd_used = 0;
1641 tp->snd_cwnd_stamp = tcp_jiffies32;
1642 } else {
1643
1644 if (tp->packets_out > tp->snd_cwnd_used)
1645 tp->snd_cwnd_used = tp->packets_out;
1646
1647 if (sock_net(sk)->ipv4.sysctl_tcp_slow_start_after_idle &&
1648 (s32)(tcp_jiffies32 - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto &&
1649 !ca_ops->cong_control)
1650 tcp_cwnd_application_limited(sk);
1651
1652
1653
1654
1655
1656
1657
1658
1659 if (tcp_write_queue_empty(sk) && sk->sk_socket &&
1660 test_bit(SOCK_NOSPACE, &sk->sk_socket->flags) &&
1661 (1 << sk->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))
1662 tcp_chrono_start(sk, TCP_CHRONO_SNDBUF_LIMITED);
1663 }
1664}
1665
1666
1667static bool tcp_minshall_check(const struct tcp_sock *tp)
1668{
1669 return after(tp->snd_sml, tp->snd_una) &&
1670 !after(tp->snd_sml, tp->snd_nxt);
1671}
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681static void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now,
1682 const struct sk_buff *skb)
1683{
1684 if (skb->len < tcp_skb_pcount(skb) * mss_now)
1685 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
1686}
1687
1688
1689
1690
1691
1692
1693
1694
1695static bool tcp_nagle_check(bool partial, const struct tcp_sock *tp,
1696 int nonagle)
1697{
1698 return partial &&
1699 ((nonagle & TCP_NAGLE_CORK) ||
1700 (!nonagle && tp->packets_out && tcp_minshall_check(tp)));
1701}
1702
1703
1704
1705
1706static u32 tcp_tso_autosize(const struct sock *sk, unsigned int mss_now,
1707 int min_tso_segs)
1708{
1709 u32 bytes, segs;
1710
1711 bytes = min(sk->sk_pacing_rate >> sk->sk_pacing_shift,
1712 sk->sk_gso_max_size - 1 - MAX_TCP_HEADER);
1713
1714
1715
1716
1717
1718
1719 segs = max_t(u32, bytes / mss_now, min_tso_segs);
1720
1721 return segs;
1722}
1723
1724
1725
1726
1727static u32 tcp_tso_segs(struct sock *sk, unsigned int mss_now)
1728{
1729 const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
1730 u32 min_tso, tso_segs;
1731
1732 min_tso = ca_ops->min_tso_segs ?
1733 ca_ops->min_tso_segs(sk) :
1734 sock_net(sk)->ipv4.sysctl_tcp_min_tso_segs;
1735
1736 tso_segs = tcp_tso_autosize(sk, mss_now, min_tso);
1737 return min_t(u32, tso_segs, sk->sk_gso_max_segs);
1738}
1739
1740
1741static unsigned int tcp_mss_split_point(const struct sock *sk,
1742 const struct sk_buff *skb,
1743 unsigned int mss_now,
1744 unsigned int max_segs,
1745 int nonagle)
1746{
1747 const struct tcp_sock *tp = tcp_sk(sk);
1748 u32 partial, needed, window, max_len;
1749
1750 window = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
1751 max_len = mss_now * max_segs;
1752
1753 if (likely(max_len <= window && skb != tcp_write_queue_tail(sk)))
1754 return max_len;
1755
1756 needed = min(skb->len, window);
1757
1758 if (max_len <= needed)
1759 return max_len;
1760
1761 partial = needed % mss_now;
1762
1763
1764
1765
1766 if (tcp_nagle_check(partial != 0, tp, nonagle))
1767 return needed - partial;
1768
1769 return needed;
1770}
1771
1772
1773
1774
1775static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp,
1776 const struct sk_buff *skb)
1777{
1778 u32 in_flight, cwnd, halfcwnd;
1779
1780
1781 if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) &&
1782 tcp_skb_pcount(skb) == 1)
1783 return 1;
1784
1785 in_flight = tcp_packets_in_flight(tp);
1786 cwnd = tp->snd_cwnd;
1787 if (in_flight >= cwnd)
1788 return 0;
1789
1790
1791
1792
1793 halfcwnd = max(cwnd >> 1, 1U);
1794 return min(halfcwnd, cwnd - in_flight);
1795}
1796
1797
1798
1799
1800
1801static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now)
1802{
1803 int tso_segs = tcp_skb_pcount(skb);
1804
1805 if (!tso_segs || (tso_segs > 1 && tcp_skb_mss(skb) != mss_now)) {
1806 tcp_set_skb_tso_segs(skb, mss_now);
1807 tso_segs = tcp_skb_pcount(skb);
1808 }
1809 return tso_segs;
1810}
1811
1812
1813
1814
1815
1816static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb,
1817 unsigned int cur_mss, int nonagle)
1818{
1819
1820
1821
1822
1823
1824
1825 if (nonagle & TCP_NAGLE_PUSH)
1826 return true;
1827
1828
1829 if (tcp_urg_mode(tp) || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN))
1830 return true;
1831
1832 if (!tcp_nagle_check(skb->len < cur_mss, tp, nonagle))
1833 return true;
1834
1835 return false;
1836}
1837
1838
1839static bool tcp_snd_wnd_test(const struct tcp_sock *tp,
1840 const struct sk_buff *skb,
1841 unsigned int cur_mss)
1842{
1843 u32 end_seq = TCP_SKB_CB(skb)->end_seq;
1844
1845 if (skb->len > cur_mss)
1846 end_seq = TCP_SKB_CB(skb)->seq + cur_mss;
1847
1848 return !after(end_seq, tcp_wnd_end(tp));
1849}
1850
1851
1852
1853
1854
1855
1856
1857
1858static int tso_fragment(struct sock *sk, enum tcp_queue tcp_queue,
1859 struct sk_buff *skb, unsigned int len,
1860 unsigned int mss_now, gfp_t gfp)
1861{
1862 struct sk_buff *buff;
1863 int nlen = skb->len - len;
1864 u8 flags;
1865
1866
1867 if (skb->len != skb->data_len)
1868 return tcp_fragment(sk, tcp_queue, skb, len, mss_now, gfp);
1869
1870 buff = sk_stream_alloc_skb(sk, 0, gfp, true);
1871 if (unlikely(!buff))
1872 return -ENOMEM;
1873
1874 sk->sk_wmem_queued += buff->truesize;
1875 sk_mem_charge(sk, buff->truesize);
1876 buff->truesize += nlen;
1877 skb->truesize -= nlen;
1878
1879
1880 TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
1881 TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
1882 TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
1883
1884
1885 flags = TCP_SKB_CB(skb)->tcp_flags;
1886 TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
1887 TCP_SKB_CB(buff)->tcp_flags = flags;
1888
1889
1890 TCP_SKB_CB(buff)->sacked = 0;
1891
1892 tcp_skb_fragment_eor(skb, buff);
1893
1894 buff->ip_summed = CHECKSUM_PARTIAL;
1895 skb_split(skb, buff, len);
1896 tcp_fragment_tstamp(skb, buff);
1897
1898
1899 tcp_set_skb_tso_segs(skb, mss_now);
1900 tcp_set_skb_tso_segs(buff, mss_now);
1901
1902
1903 __skb_header_release(buff);
1904 tcp_insert_write_queue_after(skb, buff, sk, tcp_queue);
1905
1906 return 0;
1907}
1908
1909
1910
1911
1912
1913
1914static bool tcp_tso_should_defer(struct sock *sk, struct sk_buff *skb,
1915 bool *is_cwnd_limited, u32 max_segs)
1916{
1917 const struct inet_connection_sock *icsk = inet_csk(sk);
1918 u32 age, send_win, cong_win, limit, in_flight;
1919 struct tcp_sock *tp = tcp_sk(sk);
1920 struct sk_buff *head;
1921 int win_divisor;
1922
1923 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
1924 goto send_now;
1925
1926 if (icsk->icsk_ca_state >= TCP_CA_Recovery)
1927 goto send_now;
1928
1929
1930
1931
1932 if ((s32)(tcp_jiffies32 - tp->lsndtime) > 0)
1933 goto send_now;
1934
1935 in_flight = tcp_packets_in_flight(tp);
1936
1937 BUG_ON(tcp_skb_pcount(skb) <= 1);
1938 BUG_ON(tp->snd_cwnd <= in_flight);
1939
1940 send_win = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
1941
1942
1943 cong_win = (tp->snd_cwnd - in_flight) * tp->mss_cache;
1944
1945 limit = min(send_win, cong_win);
1946
1947
1948 if (limit >= max_segs * tp->mss_cache)
1949 goto send_now;
1950
1951
1952 if ((skb != tcp_write_queue_tail(sk)) && (limit >= skb->len))
1953 goto send_now;
1954
1955 win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor);
1956 if (win_divisor) {
1957 u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache);
1958
1959
1960
1961
1962 chunk /= win_divisor;
1963 if (limit >= chunk)
1964 goto send_now;
1965 } else {
1966
1967
1968
1969
1970
1971 if (limit > tcp_max_tso_deferred_mss(tp) * tp->mss_cache)
1972 goto send_now;
1973 }
1974
1975
1976 head = tcp_rtx_queue_head(sk);
1977 if (!head)
1978 goto send_now;
1979 age = tcp_stamp_us_delta(tp->tcp_mstamp, head->skb_mstamp);
1980
1981 if (age < (tp->srtt_us >> 4))
1982 goto send_now;
1983
1984
1985
1986 if (cong_win < send_win && cong_win <= skb->len)
1987 *is_cwnd_limited = true;
1988
1989 return true;
1990
1991send_now:
1992 return false;
1993}
1994
1995static inline void tcp_mtu_check_reprobe(struct sock *sk)
1996{
1997 struct inet_connection_sock *icsk = inet_csk(sk);
1998 struct tcp_sock *tp = tcp_sk(sk);
1999 struct net *net = sock_net(sk);
2000 u32 interval;
2001 s32 delta;
2002
2003 interval = net->ipv4.sysctl_tcp_probe_interval;
2004 delta = tcp_jiffies32 - icsk->icsk_mtup.probe_timestamp;
2005 if (unlikely(delta >= interval * HZ)) {
2006 int mss = tcp_current_mss(sk);
2007
2008
2009 icsk->icsk_mtup.probe_size = 0;
2010 icsk->icsk_mtup.search_high = tp->rx_opt.mss_clamp +
2011 sizeof(struct tcphdr) +
2012 icsk->icsk_af_ops->net_header_len;
2013 icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss);
2014
2015
2016 icsk->icsk_mtup.probe_timestamp = tcp_jiffies32;
2017 }
2018}
2019
2020static bool tcp_can_coalesce_send_queue_head(struct sock *sk, int len)
2021{
2022 struct sk_buff *skb, *next;
2023
2024 skb = tcp_send_head(sk);
2025 tcp_for_write_queue_from_safe(skb, next, sk) {
2026 if (len <= skb->len)
2027 break;
2028
2029 if (unlikely(TCP_SKB_CB(skb)->eor))
2030 return false;
2031
2032 len -= skb->len;
2033 }
2034
2035 return true;
2036}
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047static int tcp_mtu_probe(struct sock *sk)
2048{
2049 struct inet_connection_sock *icsk = inet_csk(sk);
2050 struct tcp_sock *tp = tcp_sk(sk);
2051 struct sk_buff *skb, *nskb, *next;
2052 struct net *net = sock_net(sk);
2053 int probe_size;
2054 int size_needed;
2055 int copy, len;
2056 int mss_now;
2057 int interval;
2058
2059
2060
2061
2062
2063
2064 if (likely(!icsk->icsk_mtup.enabled ||
2065 icsk->icsk_mtup.probe_size ||
2066 inet_csk(sk)->icsk_ca_state != TCP_CA_Open ||
2067 tp->snd_cwnd < 11 ||
2068 tp->rx_opt.num_sacks || tp->rx_opt.dsack))
2069 return -1;
2070
2071
2072
2073
2074
2075 mss_now = tcp_current_mss(sk);
2076 probe_size = tcp_mtu_to_mss(sk, (icsk->icsk_mtup.search_high +
2077 icsk->icsk_mtup.search_low) >> 1);
2078 size_needed = probe_size + (tp->reordering + 1) * tp->mss_cache;
2079 interval = icsk->icsk_mtup.search_high - icsk->icsk_mtup.search_low;
2080
2081
2082
2083
2084 if (probe_size > tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_high) ||
2085 interval < net->ipv4.sysctl_tcp_probe_threshold) {
2086
2087
2088
2089 tcp_mtu_check_reprobe(sk);
2090 return -1;
2091 }
2092
2093
2094 if (tp->write_seq - tp->snd_nxt < size_needed)
2095 return -1;
2096
2097 if (tp->snd_wnd < size_needed)
2098 return -1;
2099 if (after(tp->snd_nxt + size_needed, tcp_wnd_end(tp)))
2100 return 0;
2101
2102
2103 if (tcp_packets_in_flight(tp) + 2 > tp->snd_cwnd) {
2104 if (!tcp_packets_in_flight(tp))
2105 return -1;
2106 else
2107 return 0;
2108 }
2109
2110 if (!tcp_can_coalesce_send_queue_head(sk, probe_size))
2111 return -1;
2112
2113
2114 nskb = sk_stream_alloc_skb(sk, probe_size, GFP_ATOMIC, false);
2115 if (!nskb)
2116 return -1;
2117 sk->sk_wmem_queued += nskb->truesize;
2118 sk_mem_charge(sk, nskb->truesize);
2119
2120 skb = tcp_send_head(sk);
2121
2122 TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(skb)->seq;
2123 TCP_SKB_CB(nskb)->end_seq = TCP_SKB_CB(skb)->seq + probe_size;
2124 TCP_SKB_CB(nskb)->tcp_flags = TCPHDR_ACK;
2125 TCP_SKB_CB(nskb)->sacked = 0;
2126 nskb->csum = 0;
2127 nskb->ip_summed = CHECKSUM_PARTIAL;
2128
2129 tcp_insert_write_queue_before(nskb, skb, sk);
2130 tcp_highest_sack_replace(sk, skb, nskb);
2131
2132 len = 0;
2133 tcp_for_write_queue_from_safe(skb, next, sk) {
2134 copy = min_t(int, skb->len, probe_size - len);
2135 skb_copy_bits(skb, 0, skb_put(nskb, copy), copy);
2136
2137 if (skb->len <= copy) {
2138
2139
2140 TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
2141
2142
2143
2144 TCP_SKB_CB(nskb)->eor = TCP_SKB_CB(skb)->eor;
2145 tcp_unlink_write_queue(skb, sk);
2146 sk_wmem_free_skb(sk, skb);
2147 } else {
2148 TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags &
2149 ~(TCPHDR_FIN|TCPHDR_PSH);
2150 if (!skb_shinfo(skb)->nr_frags) {
2151 skb_pull(skb, copy);
2152 } else {
2153 __pskb_trim_head(skb, copy);
2154 tcp_set_skb_tso_segs(skb, mss_now);
2155 }
2156 TCP_SKB_CB(skb)->seq += copy;
2157 }
2158
2159 len += copy;
2160
2161 if (len >= probe_size)
2162 break;
2163 }
2164 tcp_init_tso_segs(nskb, nskb->len);
2165
2166
2167
2168
2169 if (!tcp_transmit_skb(sk, nskb, 1, GFP_ATOMIC)) {
2170
2171
2172 tp->snd_cwnd--;
2173 tcp_event_new_data_sent(sk, nskb);
2174
2175 icsk->icsk_mtup.probe_size = tcp_mss_to_mtu(sk, nskb->len);
2176 tp->mtu_probe.probe_seq_start = TCP_SKB_CB(nskb)->seq;
2177 tp->mtu_probe.probe_seq_end = TCP_SKB_CB(nskb)->end_seq;
2178
2179 return 1;
2180 }
2181
2182 return -1;
2183}
2184
2185static bool tcp_pacing_check(const struct sock *sk)
2186{
2187 return tcp_needs_internal_pacing(sk) &&
2188 hrtimer_active(&tcp_sk(sk)->pacing_timer);
2189}
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202static bool tcp_small_queue_check(struct sock *sk, const struct sk_buff *skb,
2203 unsigned int factor)
2204{
2205 unsigned int limit;
2206
2207 limit = max(2 * skb->truesize, sk->sk_pacing_rate >> sk->sk_pacing_shift);
2208 limit = min_t(u32, limit,
2209 sock_net(sk)->ipv4.sysctl_tcp_limit_output_bytes);
2210 limit <<= factor;
2211
2212 if (refcount_read(&sk->sk_wmem_alloc) > limit) {
2213
2214
2215
2216
2217
2218 if (tcp_rtx_queue_empty(sk))
2219 return false;
2220
2221 set_bit(TSQ_THROTTLED, &sk->sk_tsq_flags);
2222
2223
2224
2225
2226 smp_mb__after_atomic();
2227 if (refcount_read(&sk->sk_wmem_alloc) > limit)
2228 return true;
2229 }
2230 return false;
2231}
2232
2233static void tcp_chrono_set(struct tcp_sock *tp, const enum tcp_chrono new)
2234{
2235 const u32 now = tcp_jiffies32;
2236 enum tcp_chrono old = tp->chrono_type;
2237
2238 if (old > TCP_CHRONO_UNSPEC)
2239 tp->chrono_stat[old - 1] += now - tp->chrono_start;
2240 tp->chrono_start = now;
2241 tp->chrono_type = new;
2242}
2243
2244void tcp_chrono_start(struct sock *sk, const enum tcp_chrono type)
2245{
2246 struct tcp_sock *tp = tcp_sk(sk);
2247
2248
2249
2250
2251
2252
2253 if (type > tp->chrono_type)
2254 tcp_chrono_set(tp, type);
2255}
2256
2257void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type)
2258{
2259 struct tcp_sock *tp = tcp_sk(sk);
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269 if (tcp_rtx_and_write_queues_empty(sk))
2270 tcp_chrono_set(tp, TCP_CHRONO_UNSPEC);
2271 else if (type == tp->chrono_type)
2272 tcp_chrono_set(tp, TCP_CHRONO_BUSY);
2273}
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
2290 int push_one, gfp_t gfp)
2291{
2292 struct tcp_sock *tp = tcp_sk(sk);
2293 struct sk_buff *skb;
2294 unsigned int tso_segs, sent_pkts;
2295 int cwnd_quota;
2296 int result;
2297 bool is_cwnd_limited = false, is_rwnd_limited = false;
2298 u32 max_segs;
2299
2300 sent_pkts = 0;
2301
2302 tcp_mstamp_refresh(tp);
2303 if (!push_one) {
2304
2305 result = tcp_mtu_probe(sk);
2306 if (!result) {
2307 return false;
2308 } else if (result > 0) {
2309 sent_pkts = 1;
2310 }
2311 }
2312
2313 max_segs = tcp_tso_segs(sk, mss_now);
2314 while ((skb = tcp_send_head(sk))) {
2315 unsigned int limit;
2316
2317 if (tcp_pacing_check(sk))
2318 break;
2319
2320 tso_segs = tcp_init_tso_segs(skb, mss_now);
2321 BUG_ON(!tso_segs);
2322
2323 if (unlikely(tp->repair) && tp->repair_queue == TCP_SEND_QUEUE) {
2324
2325 tcp_update_skb_after_send(tp, skb);
2326 goto repair;
2327 }
2328
2329 cwnd_quota = tcp_cwnd_test(tp, skb);
2330 if (!cwnd_quota) {
2331 if (push_one == 2)
2332
2333 cwnd_quota = 1;
2334 else
2335 break;
2336 }
2337
2338 if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now))) {
2339 is_rwnd_limited = true;
2340 break;
2341 }
2342
2343 if (tso_segs == 1) {
2344 if (unlikely(!tcp_nagle_test(tp, skb, mss_now,
2345 (tcp_skb_is_last(sk, skb) ?
2346 nonagle : TCP_NAGLE_PUSH))))
2347 break;
2348 } else {
2349 if (!push_one &&
2350 tcp_tso_should_defer(sk, skb, &is_cwnd_limited,
2351 max_segs))
2352 break;
2353 }
2354
2355 limit = mss_now;
2356 if (tso_segs > 1 && !tcp_urg_mode(tp))
2357 limit = tcp_mss_split_point(sk, skb, mss_now,
2358 min_t(unsigned int,
2359 cwnd_quota,
2360 max_segs),
2361 nonagle);
2362
2363 if (skb->len > limit &&
2364 unlikely(tso_fragment(sk, TCP_FRAG_IN_WRITE_QUEUE,
2365 skb, limit, mss_now, gfp)))
2366 break;
2367
2368 if (test_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags))
2369 clear_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags);
2370 if (tcp_small_queue_check(sk, skb, 0))
2371 break;
2372
2373 if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
2374 break;
2375
2376repair:
2377
2378
2379
2380 tcp_event_new_data_sent(sk, skb);
2381
2382 tcp_minshall_update(tp, mss_now, skb);
2383 sent_pkts += tcp_skb_pcount(skb);
2384
2385 if (push_one)
2386 break;
2387 }
2388
2389 if (is_rwnd_limited)
2390 tcp_chrono_start(sk, TCP_CHRONO_RWND_LIMITED);
2391 else
2392 tcp_chrono_stop(sk, TCP_CHRONO_RWND_LIMITED);
2393
2394 if (likely(sent_pkts)) {
2395 if (tcp_in_cwnd_reduction(sk))
2396 tp->prr_out += sent_pkts;
2397
2398
2399 if (push_one != 2)
2400 tcp_schedule_loss_probe(sk, false);
2401 is_cwnd_limited |= (tcp_packets_in_flight(tp) >= tp->snd_cwnd);
2402 tcp_cwnd_validate(sk, is_cwnd_limited);
2403 return false;
2404 }
2405 return !tp->packets_out && !tcp_write_queue_empty(sk);
2406}
2407
2408bool tcp_schedule_loss_probe(struct sock *sk, bool advancing_rto)
2409{
2410 struct inet_connection_sock *icsk = inet_csk(sk);
2411 struct tcp_sock *tp = tcp_sk(sk);
2412 u32 timeout, rto_delta_us;
2413 int early_retrans;
2414
2415
2416
2417
2418 if (tp->fastopen_rsk)
2419 return false;
2420
2421 early_retrans = sock_net(sk)->ipv4.sysctl_tcp_early_retrans;
2422
2423
2424
2425 if ((early_retrans != 3 && early_retrans != 4) ||
2426 !tp->packets_out || !tcp_is_sack(tp) ||
2427 (icsk->icsk_ca_state != TCP_CA_Open &&
2428 icsk->icsk_ca_state != TCP_CA_CWR))
2429 return false;
2430
2431
2432
2433
2434
2435 if (tp->srtt_us) {
2436 timeout = usecs_to_jiffies(tp->srtt_us >> 2);
2437 if (tp->packets_out == 1)
2438 timeout += TCP_RTO_MIN;
2439 else
2440 timeout += TCP_TIMEOUT_MIN;
2441 } else {
2442 timeout = TCP_TIMEOUT_INIT;
2443 }
2444
2445
2446 rto_delta_us = advancing_rto ?
2447 jiffies_to_usecs(inet_csk(sk)->icsk_rto) :
2448 tcp_rto_delta_us(sk);
2449 if (rto_delta_us > 0)
2450 timeout = min_t(u32, timeout, usecs_to_jiffies(rto_delta_us));
2451
2452 inet_csk_reset_xmit_timer(sk, ICSK_TIME_LOSS_PROBE, timeout,
2453 TCP_RTO_MAX);
2454 return true;
2455}
2456
2457
2458
2459
2460
2461static bool skb_still_in_host_queue(const struct sock *sk,
2462 const struct sk_buff *skb)
2463{
2464 if (unlikely(skb_fclone_busy(sk, skb))) {
2465 NET_INC_STATS(sock_net(sk),
2466 LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
2467 return true;
2468 }
2469 return false;
2470}
2471
2472
2473
2474
2475void tcp_send_loss_probe(struct sock *sk)
2476{
2477 struct tcp_sock *tp = tcp_sk(sk);
2478 struct sk_buff *skb;
2479 int pcount;
2480 int mss = tcp_current_mss(sk);
2481
2482 skb = tcp_send_head(sk);
2483 if (skb && tcp_snd_wnd_test(tp, skb, mss)) {
2484 pcount = tp->packets_out;
2485 tcp_write_xmit(sk, mss, TCP_NAGLE_OFF, 2, GFP_ATOMIC);
2486 if (tp->packets_out > pcount)
2487 goto probe_sent;
2488 goto rearm_timer;
2489 }
2490 skb = skb_rb_last(&sk->tcp_rtx_queue);
2491
2492
2493 if (tp->tlp_high_seq)
2494 goto rearm_timer;
2495
2496
2497 if (WARN_ON(!skb))
2498 goto rearm_timer;
2499
2500 if (skb_still_in_host_queue(sk, skb))
2501 goto rearm_timer;
2502
2503 pcount = tcp_skb_pcount(skb);
2504 if (WARN_ON(!pcount))
2505 goto rearm_timer;
2506
2507 if ((pcount > 1) && (skb->len > (pcount - 1) * mss)) {
2508 if (unlikely(tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
2509 (pcount - 1) * mss, mss,
2510 GFP_ATOMIC)))
2511 goto rearm_timer;
2512 skb = skb_rb_next(skb);
2513 }
2514
2515 if (WARN_ON(!skb || !tcp_skb_pcount(skb)))
2516 goto rearm_timer;
2517
2518 if (__tcp_retransmit_skb(sk, skb, 1))
2519 goto rearm_timer;
2520
2521
2522 tp->tlp_high_seq = tp->snd_nxt;
2523
2524probe_sent:
2525 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSPROBES);
2526
2527 inet_csk(sk)->icsk_pending = 0;
2528rearm_timer:
2529 tcp_rearm_rto(sk);
2530}
2531
2532
2533
2534
2535
2536void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
2537 int nonagle)
2538{
2539
2540
2541
2542
2543 if (unlikely(sk->sk_state == TCP_CLOSE))
2544 return;
2545
2546 if (tcp_write_xmit(sk, cur_mss, nonagle, 0,
2547 sk_gfp_mask(sk, GFP_ATOMIC)))
2548 tcp_check_probe_timer(sk);
2549}
2550
2551
2552
2553
2554void tcp_push_one(struct sock *sk, unsigned int mss_now)
2555{
2556 struct sk_buff *skb = tcp_send_head(sk);
2557
2558 BUG_ON(!skb || skb->len < mss_now);
2559
2560 tcp_write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, sk->sk_allocation);
2561}
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615u32 __tcp_select_window(struct sock *sk)
2616{
2617 struct inet_connection_sock *icsk = inet_csk(sk);
2618 struct tcp_sock *tp = tcp_sk(sk);
2619
2620
2621
2622
2623
2624
2625 int mss = icsk->icsk_ack.rcv_mss;
2626 int free_space = tcp_space(sk);
2627 int allowed_space = tcp_full_space(sk);
2628 int full_space = min_t(int, tp->window_clamp, allowed_space);
2629 int window;
2630
2631 if (unlikely(mss > full_space)) {
2632 mss = full_space;
2633 if (mss <= 0)
2634 return 0;
2635 }
2636 if (free_space < (full_space >> 1)) {
2637 icsk->icsk_ack.quick = 0;
2638
2639 if (tcp_under_memory_pressure(sk))
2640 tp->rcv_ssthresh = min(tp->rcv_ssthresh,
2641 4U * tp->advmss);
2642
2643
2644
2645
2646 free_space = round_down(free_space, 1 << tp->rx_opt.rcv_wscale);
2647
2648
2649
2650
2651
2652
2653
2654
2655 if (free_space < (allowed_space >> 4) || free_space < mss)
2656 return 0;
2657 }
2658
2659 if (free_space > tp->rcv_ssthresh)
2660 free_space = tp->rcv_ssthresh;
2661
2662
2663
2664
2665 if (tp->rx_opt.rcv_wscale) {
2666 window = free_space;
2667
2668
2669
2670
2671
2672 window = ALIGN(window, (1 << tp->rx_opt.rcv_wscale));
2673 } else {
2674 window = tp->rcv_wnd;
2675
2676
2677
2678
2679
2680
2681
2682
2683 if (window <= free_space - mss || window > free_space)
2684 window = rounddown(free_space, mss);
2685 else if (mss == full_space &&
2686 free_space > window + (full_space >> 1))
2687 window = free_space;
2688 }
2689
2690 return window;
2691}
2692
2693void tcp_skb_collapse_tstamp(struct sk_buff *skb,
2694 const struct sk_buff *next_skb)
2695{
2696 if (unlikely(tcp_has_tx_tstamp(next_skb))) {
2697 const struct skb_shared_info *next_shinfo =
2698 skb_shinfo(next_skb);
2699 struct skb_shared_info *shinfo = skb_shinfo(skb);
2700
2701 shinfo->tx_flags |= next_shinfo->tx_flags & SKBTX_ANY_TSTAMP;
2702 shinfo->tskey = next_shinfo->tskey;
2703 TCP_SKB_CB(skb)->txstamp_ack |=
2704 TCP_SKB_CB(next_skb)->txstamp_ack;
2705 }
2706}
2707
2708
2709static bool tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
2710{
2711 struct tcp_sock *tp = tcp_sk(sk);
2712 struct sk_buff *next_skb = skb_rb_next(skb);
2713 int skb_size, next_skb_size;
2714
2715 skb_size = skb->len;
2716 next_skb_size = next_skb->len;
2717
2718 BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1);
2719
2720 if (next_skb_size) {
2721 if (next_skb_size <= skb_availroom(skb))
2722 skb_copy_bits(next_skb, 0, skb_put(skb, next_skb_size),
2723 next_skb_size);
2724 else if (!skb_shift(skb, next_skb, next_skb_size))
2725 return false;
2726 }
2727 tcp_highest_sack_replace(sk, next_skb, skb);
2728
2729
2730 TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(next_skb)->end_seq;
2731
2732
2733 TCP_SKB_CB(skb)->tcp_flags |= TCP_SKB_CB(next_skb)->tcp_flags;
2734
2735
2736
2737
2738 TCP_SKB_CB(skb)->sacked |= TCP_SKB_CB(next_skb)->sacked & TCPCB_EVER_RETRANS;
2739 TCP_SKB_CB(skb)->eor = TCP_SKB_CB(next_skb)->eor;
2740
2741
2742 tcp_clear_retrans_hints_partial(tp);
2743 if (next_skb == tp->retransmit_skb_hint)
2744 tp->retransmit_skb_hint = skb;
2745
2746 tcp_adjust_pcount(sk, next_skb, tcp_skb_pcount(next_skb));
2747
2748 tcp_skb_collapse_tstamp(skb, next_skb);
2749
2750 tcp_rtx_queue_unlink_and_free(next_skb, sk);
2751 return true;
2752}
2753
2754
2755static bool tcp_can_collapse(const struct sock *sk, const struct sk_buff *skb)
2756{
2757 if (tcp_skb_pcount(skb) > 1)
2758 return false;
2759 if (skb_cloned(skb))
2760 return false;
2761
2762 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
2763 return false;
2764
2765 return true;
2766}
2767
2768
2769
2770
2771static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to,
2772 int space)
2773{
2774 struct tcp_sock *tp = tcp_sk(sk);
2775 struct sk_buff *skb = to, *tmp;
2776 bool first = true;
2777
2778 if (!sock_net(sk)->ipv4.sysctl_tcp_retrans_collapse)
2779 return;
2780 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
2781 return;
2782
2783 skb_rbtree_walk_from_safe(skb, tmp) {
2784 if (!tcp_can_collapse(sk, skb))
2785 break;
2786
2787 if (!tcp_skb_can_collapse_to(to))
2788 break;
2789
2790 space -= skb->len;
2791
2792 if (first) {
2793 first = false;
2794 continue;
2795 }
2796
2797 if (space < 0)
2798 break;
2799
2800 if (after(TCP_SKB_CB(skb)->end_seq, tcp_wnd_end(tp)))
2801 break;
2802
2803 if (!tcp_collapse_retrans(sk, to))
2804 break;
2805 }
2806}
2807
2808
2809
2810
2811
2812int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
2813{
2814 struct inet_connection_sock *icsk = inet_csk(sk);
2815 struct tcp_sock *tp = tcp_sk(sk);
2816 unsigned int cur_mss;
2817 int diff, len, err;
2818
2819
2820
2821 if (icsk->icsk_mtup.probe_size)
2822 icsk->icsk_mtup.probe_size = 0;
2823
2824
2825
2826
2827 if (refcount_read(&sk->sk_wmem_alloc) >
2828 min_t(u32, sk->sk_wmem_queued + (sk->sk_wmem_queued >> 2),
2829 sk->sk_sndbuf))
2830 return -EAGAIN;
2831
2832 if (skb_still_in_host_queue(sk, skb))
2833 return -EBUSY;
2834
2835 if (before(TCP_SKB_CB(skb)->seq, tp->snd_una)) {
2836 if (unlikely(before(TCP_SKB_CB(skb)->end_seq, tp->snd_una))) {
2837 WARN_ON_ONCE(1);
2838 return -EINVAL;
2839 }
2840 if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
2841 return -ENOMEM;
2842 }
2843
2844 if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
2845 return -EHOSTUNREACH;
2846
2847 cur_mss = tcp_current_mss(sk);
2848
2849
2850
2851
2852
2853
2854 if (!before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp)) &&
2855 TCP_SKB_CB(skb)->seq != tp->snd_una)
2856 return -EAGAIN;
2857
2858 len = cur_mss * segs;
2859 if (skb->len > len) {
2860 if (tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb, len,
2861 cur_mss, GFP_ATOMIC))
2862 return -ENOMEM;
2863 } else {
2864 if (skb_unclone(skb, GFP_ATOMIC))
2865 return -ENOMEM;
2866
2867 diff = tcp_skb_pcount(skb);
2868 tcp_set_skb_tso_segs(skb, cur_mss);
2869 diff -= tcp_skb_pcount(skb);
2870 if (diff)
2871 tcp_adjust_pcount(sk, skb, diff);
2872 if (skb->len < cur_mss)
2873 tcp_retrans_try_collapse(sk, skb, cur_mss);
2874 }
2875
2876
2877 if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN_ECN) == TCPHDR_SYN_ECN)
2878 tcp_ecn_clear_syn(sk, skb);
2879
2880
2881 segs = tcp_skb_pcount(skb);
2882 TCP_ADD_STATS(sock_net(sk), TCP_MIB_RETRANSSEGS, segs);
2883 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
2884 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
2885 tp->total_retrans += segs;
2886
2887
2888
2889
2890
2891 if (unlikely((NET_IP_ALIGN && ((unsigned long)skb->data & 3)) ||
2892 skb_headroom(skb) >= 0xFFFF)) {
2893 struct sk_buff *nskb;
2894
2895 tcp_skb_tsorted_save(skb) {
2896 nskb = __pskb_copy(skb, MAX_TCP_HEADER, GFP_ATOMIC);
2897 err = nskb ? tcp_transmit_skb(sk, nskb, 0, GFP_ATOMIC) :
2898 -ENOBUFS;
2899 } tcp_skb_tsorted_restore(skb);
2900
2901 if (!err) {
2902 tcp_update_skb_after_send(tp, skb);
2903 tcp_rate_skb_sent(sk, skb);
2904 }
2905 } else {
2906 err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
2907 }
2908
2909 if (BPF_SOCK_OPS_TEST_FLAG(tp, BPF_SOCK_OPS_RETRANS_CB_FLAG))
2910 tcp_call_bpf_3arg(sk, BPF_SOCK_OPS_RETRANS_CB,
2911 TCP_SKB_CB(skb)->seq, segs, err);
2912
2913 if (likely(!err)) {
2914 TCP_SKB_CB(skb)->sacked |= TCPCB_EVER_RETRANS;
2915 trace_tcp_retransmit_skb(sk, skb);
2916 } else if (err != -EBUSY) {
2917 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL);
2918 }
2919 return err;
2920}
2921
2922int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
2923{
2924 struct tcp_sock *tp = tcp_sk(sk);
2925 int err = __tcp_retransmit_skb(sk, skb, segs);
2926
2927 if (err == 0) {
2928#if FASTRETRANS_DEBUG > 0
2929 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
2930 net_dbg_ratelimited("retrans_out leaked\n");
2931 }
2932#endif
2933 TCP_SKB_CB(skb)->sacked |= TCPCB_RETRANS;
2934 tp->retrans_out += tcp_skb_pcount(skb);
2935
2936
2937 if (!tp->retrans_stamp)
2938 tp->retrans_stamp = tcp_skb_timestamp(skb);
2939
2940 }
2941
2942 if (tp->undo_retrans < 0)
2943 tp->undo_retrans = 0;
2944 tp->undo_retrans += tcp_skb_pcount(skb);
2945 return err;
2946}
2947
2948
2949
2950
2951
2952
2953void tcp_xmit_retransmit_queue(struct sock *sk)
2954{
2955 const struct inet_connection_sock *icsk = inet_csk(sk);
2956 struct sk_buff *skb, *rtx_head, *hole = NULL;
2957 struct tcp_sock *tp = tcp_sk(sk);
2958 u32 max_segs;
2959 int mib_idx;
2960
2961 if (!tp->packets_out)
2962 return;
2963
2964 rtx_head = tcp_rtx_queue_head(sk);
2965 skb = tp->retransmit_skb_hint ?: rtx_head;
2966 max_segs = tcp_tso_segs(sk, tcp_current_mss(sk));
2967 skb_rbtree_walk_from(skb) {
2968 __u8 sacked;
2969 int segs;
2970
2971 if (tcp_pacing_check(sk))
2972 break;
2973
2974
2975 if (!hole)
2976 tp->retransmit_skb_hint = skb;
2977
2978 segs = tp->snd_cwnd - tcp_packets_in_flight(tp);
2979 if (segs <= 0)
2980 return;
2981 sacked = TCP_SKB_CB(skb)->sacked;
2982
2983
2984
2985 segs = min_t(int, segs, max_segs);
2986
2987 if (tp->retrans_out >= tp->lost_out) {
2988 break;
2989 } else if (!(sacked & TCPCB_LOST)) {
2990 if (!hole && !(sacked & (TCPCB_SACKED_RETRANS|TCPCB_SACKED_ACKED)))
2991 hole = skb;
2992 continue;
2993
2994 } else {
2995 if (icsk->icsk_ca_state != TCP_CA_Loss)
2996 mib_idx = LINUX_MIB_TCPFASTRETRANS;
2997 else
2998 mib_idx = LINUX_MIB_TCPSLOWSTARTRETRANS;
2999 }
3000
3001 if (sacked & (TCPCB_SACKED_ACKED|TCPCB_SACKED_RETRANS))
3002 continue;
3003
3004 if (tcp_small_queue_check(sk, skb, 1))
3005 return;
3006
3007 if (tcp_retransmit_skb(sk, skb, segs))
3008 return;
3009
3010 NET_ADD_STATS(sock_net(sk), mib_idx, tcp_skb_pcount(skb));
3011
3012 if (tcp_in_cwnd_reduction(sk))
3013 tp->prr_out += tcp_skb_pcount(skb);
3014
3015 if (skb == rtx_head &&
3016 icsk->icsk_pending != ICSK_TIME_REO_TIMEOUT)
3017 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
3018 inet_csk(sk)->icsk_rto,
3019 TCP_RTO_MAX);
3020 }
3021}
3022
3023
3024
3025
3026
3027
3028
3029
3030void sk_forced_mem_schedule(struct sock *sk, int size)
3031{
3032 int amt;
3033
3034 if (size <= sk->sk_forward_alloc)
3035 return;
3036 amt = sk_mem_pages(size);
3037 sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
3038 sk_memory_allocated_add(sk, amt);
3039
3040 if (mem_cgroup_sockets_enabled && sk->sk_memcg)
3041 mem_cgroup_charge_skmem(sk->sk_memcg, amt);
3042}
3043
3044
3045
3046
3047void tcp_send_fin(struct sock *sk)
3048{
3049 struct sk_buff *skb, *tskb = tcp_write_queue_tail(sk);
3050 struct tcp_sock *tp = tcp_sk(sk);
3051
3052
3053
3054
3055
3056
3057 if (!tskb && tcp_under_memory_pressure(sk))
3058 tskb = skb_rb_last(&sk->tcp_rtx_queue);
3059
3060 if (tskb) {
3061coalesce:
3062 TCP_SKB_CB(tskb)->tcp_flags |= TCPHDR_FIN;
3063 TCP_SKB_CB(tskb)->end_seq++;
3064 tp->write_seq++;
3065 if (tcp_write_queue_empty(sk)) {
3066
3067
3068
3069
3070
3071
3072 tp->snd_nxt++;
3073 return;
3074 }
3075 } else {
3076 skb = alloc_skb_fclone(MAX_TCP_HEADER, sk->sk_allocation);
3077 if (unlikely(!skb)) {
3078 if (tskb)
3079 goto coalesce;
3080 return;
3081 }
3082 INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
3083 skb_reserve(skb, MAX_TCP_HEADER);
3084 sk_forced_mem_schedule(sk, skb->truesize);
3085
3086 tcp_init_nondata_skb(skb, tp->write_seq,
3087 TCPHDR_ACK | TCPHDR_FIN);
3088 tcp_queue_skb(sk, skb);
3089 }
3090 __tcp_push_pending_frames(sk, tcp_current_mss(sk), TCP_NAGLE_OFF);
3091}
3092
3093
3094
3095
3096
3097
3098void tcp_send_active_reset(struct sock *sk, gfp_t priority)
3099{
3100 struct sk_buff *skb;
3101
3102 TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTRSTS);
3103
3104
3105 skb = alloc_skb(MAX_TCP_HEADER, priority);
3106 if (!skb) {
3107 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
3108 return;
3109 }
3110
3111
3112 skb_reserve(skb, MAX_TCP_HEADER);
3113 tcp_init_nondata_skb(skb, tcp_acceptable_seq(sk),
3114 TCPHDR_ACK | TCPHDR_RST);
3115 tcp_mstamp_refresh(tcp_sk(sk));
3116
3117 if (tcp_transmit_skb(sk, skb, 0, priority))
3118 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
3119
3120
3121
3122
3123 trace_tcp_send_reset(sk, NULL);
3124}
3125
3126
3127
3128
3129
3130
3131
3132int tcp_send_synack(struct sock *sk)
3133{
3134 struct sk_buff *skb;
3135
3136 skb = tcp_rtx_queue_head(sk);
3137 if (!skb || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
3138 pr_err("%s: wrong queue state\n", __func__);
3139 return -EFAULT;
3140 }
3141 if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {
3142 if (skb_cloned(skb)) {
3143 struct sk_buff *nskb;
3144
3145 tcp_skb_tsorted_save(skb) {
3146 nskb = skb_copy(skb, GFP_ATOMIC);
3147 } tcp_skb_tsorted_restore(skb);
3148 if (!nskb)
3149 return -ENOMEM;
3150 INIT_LIST_HEAD(&nskb->tcp_tsorted_anchor);
3151 tcp_rtx_queue_unlink_and_free(skb, sk);
3152 __skb_header_release(nskb);
3153 tcp_rbtree_insert(&sk->tcp_rtx_queue, nskb);
3154 sk->sk_wmem_queued += nskb->truesize;
3155 sk_mem_charge(sk, nskb->truesize);
3156 skb = nskb;
3157 }
3158
3159 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
3160 tcp_ecn_send_synack(sk, skb);
3161 }
3162 return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
3163}
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,
3175 struct request_sock *req,
3176 struct tcp_fastopen_cookie *foc,
3177 enum tcp_synack_type synack_type)
3178{
3179 struct inet_request_sock *ireq = inet_rsk(req);
3180 const struct tcp_sock *tp = tcp_sk(sk);
3181 struct tcp_md5sig_key *md5 = NULL;
3182 struct tcp_out_options opts;
3183 struct sk_buff *skb;
3184 int tcp_header_size;
3185 struct tcphdr *th;
3186 int mss;
3187
3188 skb = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC);
3189 if (unlikely(!skb)) {
3190 dst_release(dst);
3191 return NULL;
3192 }
3193
3194 skb_reserve(skb, MAX_TCP_HEADER);
3195
3196 switch (synack_type) {
3197 case TCP_SYNACK_NORMAL:
3198 skb_set_owner_w(skb, req_to_sk(req));
3199 break;
3200 case TCP_SYNACK_COOKIE:
3201
3202
3203
3204 break;
3205 case TCP_SYNACK_FASTOPEN:
3206
3207
3208
3209
3210 skb_set_owner_w(skb, (struct sock *)sk);
3211 break;
3212 }
3213 skb_dst_set(skb, dst);
3214
3215 mss = tcp_mss_clamp(tp, dst_metric_advmss(dst));
3216
3217 memset(&opts, 0, sizeof(opts));
3218#ifdef CONFIG_SYN_COOKIES
3219 if (unlikely(req->cookie_ts))
3220 skb->skb_mstamp = cookie_init_timestamp(req);
3221 else
3222#endif
3223 skb->skb_mstamp = tcp_clock_us();
3224
3225#ifdef CONFIG_TCP_MD5SIG
3226 rcu_read_lock();
3227 md5 = tcp_rsk(req)->af_specific->req_md5_lookup(sk, req_to_sk(req));
3228#endif
3229 skb_set_hash(skb, tcp_rsk(req)->txhash, PKT_HASH_TYPE_L4);
3230 tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, md5,
3231 foc) + sizeof(*th);
3232
3233 skb_push(skb, tcp_header_size);
3234 skb_reset_transport_header(skb);
3235
3236 th = (struct tcphdr *)skb->data;
3237 memset(th, 0, sizeof(struct tcphdr));
3238 th->syn = 1;
3239 th->ack = 1;
3240 tcp_ecn_make_synack(req, th);
3241 th->source = htons(ireq->ir_num);
3242 th->dest = ireq->ir_rmt_port;
3243 skb->mark = ireq->ir_mark;
3244 skb->ip_summed = CHECKSUM_PARTIAL;
3245 th->seq = htonl(tcp_rsk(req)->snt_isn);
3246
3247 th->ack_seq = htonl(tcp_rsk(req)->rcv_nxt);
3248
3249
3250 th->window = htons(min(req->rsk_rcv_wnd, 65535U));
3251 tcp_options_write((__be32 *)(th + 1), NULL, &opts);
3252 th->doff = (tcp_header_size >> 2);
3253 __TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
3254
3255#ifdef CONFIG_TCP_MD5SIG
3256
3257 if (md5)
3258 tcp_rsk(req)->af_specific->calc_md5_hash(opts.hash_location,
3259 md5, req_to_sk(req), skb);
3260 rcu_read_unlock();
3261#endif
3262
3263
3264 skb->tstamp = 0;
3265 return skb;
3266}
3267EXPORT_SYMBOL(tcp_make_synack);
3268
3269static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst)
3270{
3271 struct inet_connection_sock *icsk = inet_csk(sk);
3272 const struct tcp_congestion_ops *ca;
3273 u32 ca_key = dst_metric(dst, RTAX_CC_ALGO);
3274
3275 if (ca_key == TCP_CA_UNSPEC)
3276 return;
3277
3278 rcu_read_lock();
3279 ca = tcp_ca_find_key(ca_key);
3280 if (likely(ca && try_module_get(ca->owner))) {
3281 module_put(icsk->icsk_ca_ops->owner);
3282 icsk->icsk_ca_dst_locked = tcp_ca_dst_locked(dst);
3283 icsk->icsk_ca_ops = ca;
3284 }
3285 rcu_read_unlock();
3286}
3287
3288
3289static void tcp_connect_init(struct sock *sk)
3290{
3291 const struct dst_entry *dst = __sk_dst_get(sk);
3292 struct tcp_sock *tp = tcp_sk(sk);
3293 __u8 rcv_wscale;
3294 u32 rcv_wnd;
3295
3296
3297
3298
3299 tp->tcp_header_len = sizeof(struct tcphdr);
3300 if (sock_net(sk)->ipv4.sysctl_tcp_timestamps)
3301 tp->tcp_header_len += TCPOLEN_TSTAMP_ALIGNED;
3302
3303#ifdef CONFIG_TCP_MD5SIG
3304 if (tp->af_specific->md5_lookup(sk, sk))
3305 tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
3306#endif
3307
3308
3309 if (tp->rx_opt.user_mss)
3310 tp->rx_opt.mss_clamp = tp->rx_opt.user_mss;
3311 tp->max_window = 0;
3312 tcp_mtup_init(sk);
3313 tcp_sync_mss(sk, dst_mtu(dst));
3314
3315 tcp_ca_dst_init(sk, dst);
3316
3317 if (!tp->window_clamp)
3318 tp->window_clamp = dst_metric(dst, RTAX_WINDOW);
3319 tp->advmss = tcp_mss_clamp(tp, dst_metric_advmss(dst));
3320
3321 tcp_initialize_rcv_mss(sk);
3322
3323
3324 if (sk->sk_userlocks & SOCK_RCVBUF_LOCK &&
3325 (tp->window_clamp > tcp_full_space(sk) || tp->window_clamp == 0))
3326 tp->window_clamp = tcp_full_space(sk);
3327
3328 rcv_wnd = tcp_rwnd_init_bpf(sk);
3329 if (rcv_wnd == 0)
3330 rcv_wnd = dst_metric(dst, RTAX_INITRWND);
3331
3332 tcp_select_initial_window(sk, tcp_full_space(sk),
3333 tp->advmss - (tp->rx_opt.ts_recent_stamp ? tp->tcp_header_len - sizeof(struct tcphdr) : 0),
3334 &tp->rcv_wnd,
3335 &tp->window_clamp,
3336 sock_net(sk)->ipv4.sysctl_tcp_window_scaling,
3337 &rcv_wscale,
3338 rcv_wnd);
3339
3340 tp->rx_opt.rcv_wscale = rcv_wscale;
3341 tp->rcv_ssthresh = tp->rcv_wnd;
3342
3343 sk->sk_err = 0;
3344 sock_reset_flag(sk, SOCK_DONE);
3345 tp->snd_wnd = 0;
3346 tcp_init_wl(tp, 0);
3347 tcp_write_queue_purge(sk);
3348 tp->snd_una = tp->write_seq;
3349 tp->snd_sml = tp->write_seq;
3350 tp->snd_up = tp->write_seq;
3351 tp->snd_nxt = tp->write_seq;
3352
3353 if (likely(!tp->repair))
3354 tp->rcv_nxt = 0;
3355 else
3356 tp->rcv_tstamp = tcp_jiffies32;
3357 tp->rcv_wup = tp->rcv_nxt;
3358 tp->copied_seq = tp->rcv_nxt;
3359
3360 inet_csk(sk)->icsk_rto = tcp_timeout_init(sk);
3361 inet_csk(sk)->icsk_retransmits = 0;
3362 tcp_clear_retrans(tp);
3363}
3364
3365static void tcp_connect_queue_skb(struct sock *sk, struct sk_buff *skb)
3366{
3367 struct tcp_sock *tp = tcp_sk(sk);
3368 struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
3369
3370 tcb->end_seq += skb->len;
3371 __skb_header_release(skb);
3372 sk->sk_wmem_queued += skb->truesize;
3373 sk_mem_charge(sk, skb->truesize);
3374 tp->write_seq = tcb->end_seq;
3375 tp->packets_out += tcp_skb_pcount(skb);
3376}
3377
3378
3379
3380
3381
3382
3383
3384
3385static int tcp_send_syn_data(struct sock *sk, struct sk_buff *syn)
3386{
3387 struct tcp_sock *tp = tcp_sk(sk);
3388 struct tcp_fastopen_request *fo = tp->fastopen_req;
3389 int space, err = 0;
3390 struct sk_buff *syn_data;
3391
3392 tp->rx_opt.mss_clamp = tp->advmss;
3393 if (!tcp_fastopen_cookie_check(sk, &tp->rx_opt.mss_clamp, &fo->cookie))
3394 goto fallback;
3395
3396
3397
3398
3399
3400 tp->rx_opt.mss_clamp = tcp_mss_clamp(tp, tp->rx_opt.mss_clamp);
3401
3402 space = __tcp_mtu_to_mss(sk, inet_csk(sk)->icsk_pmtu_cookie) -
3403 MAX_TCP_OPTION_SPACE;
3404
3405 space = min_t(size_t, space, fo->size);
3406
3407
3408 space = min_t(size_t, space, SKB_MAX_HEAD(MAX_TCP_HEADER));
3409
3410 syn_data = sk_stream_alloc_skb(sk, space, sk->sk_allocation, false);
3411 if (!syn_data)
3412 goto fallback;
3413 syn_data->ip_summed = CHECKSUM_PARTIAL;
3414 memcpy(syn_data->cb, syn->cb, sizeof(syn->cb));
3415 if (space) {
3416 int copied = copy_from_iter(skb_put(syn_data, space), space,
3417 &fo->data->msg_iter);
3418 if (unlikely(!copied)) {
3419 tcp_skb_tsorted_anchor_cleanup(syn_data);
3420 kfree_skb(syn_data);
3421 goto fallback;
3422 }
3423 if (copied != space) {
3424 skb_trim(syn_data, copied);
3425 space = copied;
3426 }
3427 }
3428
3429 if (space == fo->size)
3430 fo->data = NULL;
3431 fo->copied = space;
3432
3433 tcp_connect_queue_skb(sk, syn_data);
3434 if (syn_data->len)
3435 tcp_chrono_start(sk, TCP_CHRONO_BUSY);
3436
3437 err = tcp_transmit_skb(sk, syn_data, 1, sk->sk_allocation);
3438
3439 syn->skb_mstamp = syn_data->skb_mstamp;
3440
3441
3442
3443
3444
3445
3446 TCP_SKB_CB(syn_data)->seq++;
3447 TCP_SKB_CB(syn_data)->tcp_flags = TCPHDR_ACK | TCPHDR_PSH;
3448 if (!err) {
3449 tp->syn_data = (fo->copied > 0);
3450 tcp_rbtree_insert(&sk->tcp_rtx_queue, syn_data);
3451 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPORIGDATASENT);
3452 goto done;
3453 }
3454
3455
3456 __skb_queue_tail(&sk->sk_write_queue, syn_data);
3457 tp->packets_out -= tcp_skb_pcount(syn_data);
3458
3459fallback:
3460
3461 if (fo->cookie.len > 0)
3462 fo->cookie.len = 0;
3463 err = tcp_transmit_skb(sk, syn, 1, sk->sk_allocation);
3464 if (err)
3465 tp->syn_fastopen = 0;
3466done:
3467 fo->cookie.len = -1;
3468 return err;
3469}
3470
3471
3472int tcp_connect(struct sock *sk)
3473{
3474 struct tcp_sock *tp = tcp_sk(sk);
3475 struct sk_buff *buff;
3476 int err;
3477
3478 tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_CONNECT_CB, 0, NULL);
3479
3480 if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
3481 return -EHOSTUNREACH;
3482
3483 tcp_connect_init(sk);
3484
3485 if (unlikely(tp->repair)) {
3486 tcp_finish_connect(sk, NULL);
3487 return 0;
3488 }
3489
3490 buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true);
3491 if (unlikely(!buff))
3492 return -ENOBUFS;
3493
3494 tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
3495 tcp_mstamp_refresh(tp);
3496 tp->retrans_stamp = tcp_time_stamp(tp);
3497 tcp_connect_queue_skb(sk, buff);
3498 tcp_ecn_send_syn(sk, buff);
3499 tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);
3500
3501
3502 err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
3503 tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
3504 if (err == -ECONNREFUSED)
3505 return err;
3506
3507
3508
3509
3510 tp->snd_nxt = tp->write_seq;
3511 tp->pushed_seq = tp->write_seq;
3512 buff = tcp_send_head(sk);
3513 if (unlikely(buff)) {
3514 tp->snd_nxt = TCP_SKB_CB(buff)->seq;
3515 tp->pushed_seq = TCP_SKB_CB(buff)->seq;
3516 }
3517 TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);
3518
3519
3520 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
3521 inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
3522 return 0;
3523}
3524EXPORT_SYMBOL(tcp_connect);
3525
3526
3527
3528
3529
3530void tcp_send_delayed_ack(struct sock *sk)
3531{
3532 struct inet_connection_sock *icsk = inet_csk(sk);
3533 int ato = icsk->icsk_ack.ato;
3534 unsigned long timeout;
3535
3536 tcp_ca_event(sk, CA_EVENT_DELAYED_ACK);
3537
3538 if (ato > TCP_DELACK_MIN) {
3539 const struct tcp_sock *tp = tcp_sk(sk);
3540 int max_ato = HZ / 2;
3541
3542 if (icsk->icsk_ack.pingpong ||
3543 (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
3544 max_ato = TCP_DELACK_MAX;
3545
3546
3547
3548
3549
3550
3551
3552 if (tp->srtt_us) {
3553 int rtt = max_t(int, usecs_to_jiffies(tp->srtt_us >> 3),
3554 TCP_DELACK_MIN);
3555
3556 if (rtt < max_ato)
3557 max_ato = rtt;
3558 }
3559
3560 ato = min(ato, max_ato);
3561 }
3562
3563
3564 timeout = jiffies + ato;
3565
3566
3567 if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
3568
3569
3570
3571 if (icsk->icsk_ack.blocked ||
3572 time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
3573 tcp_send_ack(sk);
3574 return;
3575 }
3576
3577 if (!time_before(timeout, icsk->icsk_ack.timeout))
3578 timeout = icsk->icsk_ack.timeout;
3579 }
3580 icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
3581 icsk->icsk_ack.timeout = timeout;
3582 sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
3583}
3584
3585
3586void tcp_send_ack(struct sock *sk)
3587{
3588 struct sk_buff *buff;
3589
3590
3591 if (sk->sk_state == TCP_CLOSE)
3592 return;
3593
3594 tcp_ca_event(sk, CA_EVENT_NON_DELAYED_ACK);
3595
3596
3597
3598
3599
3600 buff = alloc_skb(MAX_TCP_HEADER,
3601 sk_gfp_mask(sk, GFP_ATOMIC | __GFP_NOWARN));
3602 if (unlikely(!buff)) {
3603 inet_csk_schedule_ack(sk);
3604 inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
3605 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
3606 TCP_DELACK_MAX, TCP_RTO_MAX);
3607 return;
3608 }
3609
3610
3611 skb_reserve(buff, MAX_TCP_HEADER);
3612 tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);
3613
3614
3615
3616
3617
3618 skb_set_tcp_pure_ack(buff);
3619
3620
3621 tcp_transmit_skb(sk, buff, 0, (__force gfp_t)0);
3622}
3623EXPORT_SYMBOL_GPL(tcp_send_ack);
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636static int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib)
3637{
3638 struct tcp_sock *tp = tcp_sk(sk);
3639 struct sk_buff *skb;
3640
3641
3642 skb = alloc_skb(MAX_TCP_HEADER,
3643 sk_gfp_mask(sk, GFP_ATOMIC | __GFP_NOWARN));
3644 if (!skb)
3645 return -1;
3646
3647
3648 skb_reserve(skb, MAX_TCP_HEADER);
3649
3650
3651
3652
3653 tcp_init_nondata_skb(skb, tp->snd_una - !urgent, TCPHDR_ACK);
3654 NET_INC_STATS(sock_net(sk), mib);
3655 return tcp_transmit_skb(sk, skb, 0, (__force gfp_t)0);
3656}
3657
3658
3659void tcp_send_window_probe(struct sock *sk)
3660{
3661 if (sk->sk_state == TCP_ESTABLISHED) {
3662 tcp_sk(sk)->snd_wl1 = tcp_sk(sk)->rcv_nxt - 1;
3663 tcp_mstamp_refresh(tcp_sk(sk));
3664 tcp_xmit_probe_skb(sk, 0, LINUX_MIB_TCPWINPROBE);
3665 }
3666}
3667
3668
3669int tcp_write_wakeup(struct sock *sk, int mib)
3670{
3671 struct tcp_sock *tp = tcp_sk(sk);
3672 struct sk_buff *skb;
3673
3674 if (sk->sk_state == TCP_CLOSE)
3675 return -1;
3676
3677 skb = tcp_send_head(sk);
3678 if (skb && before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp))) {
3679 int err;
3680 unsigned int mss = tcp_current_mss(sk);
3681 unsigned int seg_size = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
3682
3683 if (before(tp->pushed_seq, TCP_SKB_CB(skb)->end_seq))
3684 tp->pushed_seq = TCP_SKB_CB(skb)->end_seq;
3685
3686
3687
3688
3689
3690 if (seg_size < TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq ||
3691 skb->len > mss) {
3692 seg_size = min(seg_size, mss);
3693 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
3694 if (tcp_fragment(sk, TCP_FRAG_IN_WRITE_QUEUE,
3695 skb, seg_size, mss, GFP_ATOMIC))
3696 return -1;
3697 } else if (!tcp_skb_pcount(skb))
3698 tcp_set_skb_tso_segs(skb, mss);
3699
3700 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
3701 err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
3702 if (!err)
3703 tcp_event_new_data_sent(sk, skb);
3704 return err;
3705 } else {
3706 if (between(tp->snd_up, tp->snd_una + 1, tp->snd_una + 0xFFFF))
3707 tcp_xmit_probe_skb(sk, 1, mib);
3708 return tcp_xmit_probe_skb(sk, 0, mib);
3709 }
3710}
3711
3712
3713
3714
3715void tcp_send_probe0(struct sock *sk)
3716{
3717 struct inet_connection_sock *icsk = inet_csk(sk);
3718 struct tcp_sock *tp = tcp_sk(sk);
3719 struct net *net = sock_net(sk);
3720 unsigned long probe_max;
3721 int err;
3722
3723 err = tcp_write_wakeup(sk, LINUX_MIB_TCPWINPROBE);
3724
3725 if (tp->packets_out || tcp_write_queue_empty(sk)) {
3726
3727 icsk->icsk_probes_out = 0;
3728 icsk->icsk_backoff = 0;
3729 return;
3730 }
3731
3732 if (err <= 0) {
3733 if (icsk->icsk_backoff < net->ipv4.sysctl_tcp_retries2)
3734 icsk->icsk_backoff++;
3735 icsk->icsk_probes_out++;
3736 probe_max = TCP_RTO_MAX;
3737 } else {
3738
3739
3740
3741
3742
3743
3744 if (!icsk->icsk_probes_out)
3745 icsk->icsk_probes_out = 1;
3746 probe_max = TCP_RESOURCE_PROBE_INTERVAL;
3747 }
3748 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3749 tcp_probe0_when(sk, probe_max),
3750 TCP_RTO_MAX);
3751}
3752
3753int tcp_rtx_synack(const struct sock *sk, struct request_sock *req)
3754{
3755 const struct tcp_request_sock_ops *af_ops = tcp_rsk(req)->af_specific;
3756 struct flowi fl;
3757 int res;
3758
3759 tcp_rsk(req)->txhash = net_tx_rndhash();
3760 res = af_ops->send_synack(sk, NULL, &fl, req, NULL, TCP_SYNACK_NORMAL);
3761 if (!res) {
3762 __TCP_INC_STATS(sock_net(sk), TCP_MIB_RETRANSSEGS);
3763 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
3764 if (unlikely(tcp_passive_fastopen(sk)))
3765 tcp_sk(sk)->total_retrans++;
3766 trace_tcp_retransmit_synack(sk, req);
3767 }
3768 return res;
3769}
3770EXPORT_SYMBOL(tcp_rtx_synack);
3771